Resolve from hosts config using lower case

src/main/java/io/vertx/core/impl/AddressResolver.java

@@ -20,6 +20,7 @@
 import io.netty.channel.socket.nio.NioDatagramChannel;
 import io.netty.resolver.AddressResolverGroup;
 import io.netty.resolver.DefaultAddressResolverGroup;
+import io.netty.resolver.HostsFileEntriesResolver;
 import io.netty.resolver.HostsFileParser;
 import io.netty.resolver.InetSocketAddressResolver;
 import io.netty.resolver.dns.DnsServerAddresses;
@@ -42,6 +43,7 @@
 import java.net.UnknownHostException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 
 /**
@@ -114,7 +116,13 @@ public AddressResolver(VertxImpl vertx, AddressResolverOptions options) {
           }
         } catch (UnknownHostException ignore) {
         }
-        builder.hostsFileEntriesResolver(entries::get);
+        builder.hostsFileEntriesResolver(inetHost -> {
+          InetAddress addr = entries.get(inetHost);
+          if (addr == null) {
+            addr = entries.get(inetHost.toLowerCase(Locale.ENGLISH));
+          }
+          return addr;
+        });
 
         builder.optResourceEnabled(options.isOptResourceEnabled());
         builder.ttl(options.getCacheMinTimeToLive(), options.getCacheMaxTimeToLive());

src/test/java/io/vertx/test/core/HostnameResolutionTest.java

@@ -379,6 +379,17 @@ public void testResolveFromBuffer() {
     await();
   }
 
+  @Test
+  public void testCaseInsensitiveResolveFromHosts() {
+    VertxInternal vertx = (VertxInternal) vertx(new VertxOptions().setAddressResolverOptions(new AddressResolverOptions().setHostsPath("hosts_config.txt")));
+    vertx.resolveAddress("SERVER.NET", onSuccess(addr -> {
+      assertEquals("192.168.0.15", addr.getHostAddress());
+      assertEquals("server.net", addr.getHostName());
+      testComplete();
+    }));
+    await();
+  }
+
   @Test
   public void testResolveMissingLocalhost() throws Exception {
 
@@ -397,46 +408,61 @@ public void testResolveMissingLocalhost() throws Exception {
             addServer(dnsServerAddress.getAddress().getHostAddress() + ":" + dnsServerAddress.getPort()).
             setOptResourceEnabled(false)
     ));
-    CompletableFuture<Void> test = new CompletableFuture<>();
+    CompletableFuture<Void> test1 = new CompletableFuture<>();
     vertx.resolveAddress("localhost", ar -> {
       if (ar.succeeded()) {
         InetAddress resolved = ar.result();
         if (resolved.equals(localhost)) {
-          test.complete(null);
+          test1.complete(null);
         } else {
-          test.completeExceptionally(new AssertionError("Unexpected localhost value " + resolved));
+          test1.completeExceptionally(new AssertionError("Unexpected localhost value " + resolved));
         }
       } else {
-        test.completeExceptionally(ar.cause());
+        test1.completeExceptionally(ar.cause());
       }
     });
-    test.get(10, TimeUnit.SECONDS);
+    test1.get(10, TimeUnit.SECONDS);
 
-    // Test using bootstrap
     CompletableFuture<Void> test2 = new CompletableFuture<>();
+    vertx.resolveAddress("LOCALHOST", ar -> {
+      if (ar.succeeded()) {
+        InetAddress resolved = ar.result();
+        if (resolved.equals(localhost)) {
+          test2.complete(null);
+        } else {
+          test2.completeExceptionally(new AssertionError("Unexpected localhost value " + resolved));
+        }
+      } else {
+        test2.completeExceptionally(ar.cause());
+      }
+    });
+    test2.get(10, TimeUnit.SECONDS);
+
+    // Test using bootstrap
+    CompletableFuture<Void> test3 = new CompletableFuture<>();
     NetServer server = vertx.createNetServer(new NetServerOptions().setPort(1234).setHost(localhost.getHostAddress()));
     server.connectHandler(so -> {
       so.write("hello").end();
     });
     server.listen(ar -> {
       if (ar.succeeded()) {
-        test2.complete(null);
+        test3.complete(null);
       } else {
-        test2.completeExceptionally(ar.cause());
+        test3.completeExceptionally(ar.cause());
       }
     });
-    test2.get(10, TimeUnit.SECONDS);
+    test3.get(10, TimeUnit.SECONDS);
 
-    CompletableFuture<Void> test3 = new CompletableFuture<>();
+    CompletableFuture<Void> test4 = new CompletableFuture<>();
     NetClient client = vertx.createNetClient();
     client.connect(1234, "localhost", ar -> {
       if (ar.succeeded()) {
-        test3.complete(null);
+        test4.complete(null);
       } else {
-        test3.completeExceptionally(ar.cause());
+        test4.completeExceptionally(ar.cause());
       }
     });
-    test3.get(10, TimeUnit.SECONDS);
+    test4.get(10, TimeUnit.SECONDS);
   }
 
   @Test