Add new InternetAddress class with a static lookup function (including IPv6

tests/standalone/io/http_proxy_test.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import "package:expect/expect.dart";
 import "dart:async";
 import 'dart:crypto';
 import "dart:io";
 import "dart:uri";
 import 'dart:utf';
 
 class Server {
   HttpServer server;
   bool secure;
   int proxyHops;
   List<String> directRequestPaths;
   int requestCount = 0;
 
   Server(this.proxyHops, this.directRequestPaths, this.secure);
 
   Future<Server> start() {
     var x = new Completer();
     Future f = secure
         ? HttpServer.bindSecure(
-            "127.0.0.1", 0, certificateName: 'localhost_cert')
-        : HttpServer.bind();
+            "localhost", 0, certificateName: 'localhost_cert')
+        : HttpServer.bind("localhost");
     return f.then((s) {
       server = s;
       x.complete(this);
       server.listen((request) {
         var response = request.response;
         requestCount++;
         // Check whether a proxy or direct connection is expected.
         bool direct = directRequestPaths.fold(
             false,
             (prev, path) => prev ? prev : path == request.uri.path);
@@ skipping 53 matching lines @@
       var response = request.response;
       response.headers.set(HttpHeaders.PROXY_AUTHENTICATE,
                            "Basic, realm=realm");
       response.statusCode = HttpStatus.PROXY_AUTHENTICATION_REQUIRED;
       response.close();
     });
   }
 
   Future<ProxyServer> start() {
     var x = new Completer();
-    HttpServer.bind().then((s) {
+    HttpServer.bind("localhost").then((s) {
       server = s;
       x.complete(this);
       server.listen((HttpRequest request) {
         requestCount++;
         if (username != null && password != null) {
           if (request.headers[HttpHeaders.PROXY_AUTHORIZATION] == null) {
             authenticationRequired(request);
             return;
           } else {
             Expect.equals(
@@ skipping 78 matching lines @@
     List<String> proxy =
         ["DIRECT", " DIRECT ", "DIRECT ;", " DIRECT ; ",
          ";DIRECT", " ; DIRECT ", ";;DIRECT;;"];
 
     client.findProxy = (Uri uri) {
       int index = int.parse(uri.path.substring(1));
       return proxy[index];
     };
 
     for (int i = 0; i < proxy.length; i++) {
-      client.getUrl(Uri.parse("http://127.0.0.1:${server.port}/$i"))
+      client.getUrl(Uri.parse("http://localhost:${server.port}/$i"))
         .then((HttpClientRequest clientRequest) {
           String content = "$i$i$i";
           clientRequest.contentLength = content.length;
           clientRequest.write(content);
           return clientRequest.close();
         })
        .then((HttpClientResponse response) {
           response.listen((_) {}, onDone: () {
             testDirectDoneCount++;
             if (testDirectDoneCount == proxy.length) {
@@ skipping 37 matching lines @@
     client.findProxy = (Uri uri) {
       // Pick the proxy configuration based on the request path.
       int index = int.parse(uri.path.substring(1));
       return proxy[index];
     };
 
     for (int i = 0; i < proxy.length; i++) {
       test(bool secure) {
         String url = secure
             ? "https://localhost:${secureServer.port}/$i"
-            : "http://127.0.0.1:${server.port}/$i";
+            : "http://localhost:${server.port}/$i";
 
         client.postUrl(Uri.parse(url))
           .then((HttpClientRequest clientRequest) {
             String content = "$i$i$i";
             clientRequest.write(content);
             return clientRequest.close();
           })
           .then((HttpClientResponse response) {
             response.listen((_) {}, onDone: () {
               testProxyDoneCount++;
@@ skipping 15 matching lines @@
   });
   });
   });
 }
 
 int testProxyChainDoneCount = 0;
 void testProxyChain() {
   // Setup two proxy servers having the first using the second as its proxy.
   setupProxyServer().then((proxyServer1) {
   setupProxyServer().then((proxyServer2) {
-  proxyServer1.client.findProxy = (_) => "PROXY 127.0.0.1:${proxyServer2.port}";
+  proxyServer1.client.findProxy = (_) => "PROXY localhost:${proxyServer2.port}";
 
   setupServer(2, directRequestPaths: ["/4"]).then((server) {
     HttpClient client = new HttpClient();
 
     List<String> proxy;
     if (Platform.operatingSystem == "windows") {
       proxy =
           ["PROXY localhost:${proxyServer1.port}",
            "PROXY localhost:${proxyServer1.port}; PROXY hede.hule.hest:8080",
            "PROXY localhost:${proxyServer1.port}",
@@ skipping 11 matching lines @@
            "PROXY localhost:${proxyServer1.port}; DIRECT"];
     }
 
     client.findProxy = (Uri uri) {
       // Pick the proxy configuration based on the request path.
       int index = int.parse(uri.path.substring(1));
       return proxy[index];
     };
 
     for (int i = 0; i < proxy.length; i++) {
-      client.getUrl(Uri.parse("http://127.0.0.1:${server.port}/$i"))
+      client.getUrl(Uri.parse("http://localhost:${server.port}/$i"))
         .then((HttpClientRequest clientRequest) {
           String content = "$i$i$i";
           clientRequest.contentLength = content.length;
           clientRequest.write(content);
           return clientRequest.close();
         })
         .then((HttpClientResponse response) {
           response.listen((_) {}, onDone: () {
             testProxyChainDoneCount++;
             if (testProxyChainDoneCount == proxy.length) {
@@ skipping 23 matching lines @@
           uri,
           environment: {"http_proxy": "localhost:${proxyServer.port}",
                         "https_proxy": "localhost:${proxyServer.port}"});
     };
 
     const int loopCount = 5;
     for (int i = 0; i < loopCount; i++) {
       test(bool secure) {
         String url = secure
             ? "https://localhost:${secureServer.port}/$i"
-            : "http://127.0.0.1:${server.port}/$i";
+            : "http://localhost:${server.port}/$i";
 
         client.postUrl(Uri.parse(url))
           .then((HttpClientRequest clientRequest) {
             String content = "$i$i$i";
             clientRequest.write(content);
             return clientRequest.close();
           })
           .then((HttpClientResponse response) {
             response.listen((_) {}, onDone: () {
               testProxyFromEnviromentDoneCount++;
@@ skipping 33 matching lines @@
     // Test with no authentication.
     client.findProxy = (Uri uri) {
       return "PROXY localhost:${proxyServer.port}";
     };
 
     const int loopCount = 2;
     for (int i = 0; i < loopCount; i++) {
       test(bool secure) {
         String url = secure
             ? "https://localhost:${secureServer.port}/$i"
-            : "http://127.0.0.1:${server.port}/$i";
+            : "http://localhost:${server.port}/$i";
 
         client.postUrl(Uri.parse(url))
           .then((HttpClientRequest clientRequest) {
             String content = "$i$i$i";
             clientRequest.write(content);
             return clientRequest.close();
           })
           .then((HttpClientResponse response) {
             response.listen((_) {}, onDone: () {
               testProxyAuthenticateCount++;
@@ skipping 15 matching lines @@
     step1.future.then((_) {
       testProxyAuthenticateCount = 0;
       client.findProxy = (Uri uri) {
         return "PROXY test:test@localhost:${proxyServer.port}";
       };
 
       for (int i = 0; i < loopCount; i++) {
         test(bool secure) {
           String url = secure
               ? "https://localhost:${secureServer.port}/$i"
-              : "http://127.0.0.1:${server.port}/$i";
+              : "http://localhost:${server.port}/$i";
 
           client.postUrl(Uri.parse(url))
             .then((HttpClientRequest clientRequest) {
               String content = "$i$i$i";
               clientRequest.write(content);
               return clientRequest.close();
             })
             .then((HttpClientResponse response) {
               response.listen((_) {}, onDone: () {
                 testProxyAuthenticateCount++;
@@ skipping 24 matching lines @@
             proxyServer.port,
             "realm",
             new HttpClientBasicCredentials("test", "test"));
         return new Future.value(true);
       };
 
       for (int i = 0; i < loopCount; i++) {
         test(bool secure) {
           String url = secure
               ? "https://localhost:${secureServer.port}/A"
-              : "http://127.0.0.1:${server.port}/A";
+              : "http://localhost:${server.port}/A";
 
           client.postUrl(Uri.parse(url))
             .then((HttpClientRequest clientRequest) {
               String content = "$i$i$i";
               clientRequest.write(content);
               return clientRequest.close();
             })
             .then((HttpClientResponse response) {
               response.listen((_) {}, onDone: () {
                 testProxyAuthenticateCount++;
@@ skipping 34 matching lines @@
          "PROXY hede.hule.hest:8080; PROXY localhost:8080",
          "PROXY localhost:8080; DIRECT"];
 
     client.findProxy = (Uri uri) {
       // Pick the proxy configuration based on the request path.
       int index = int.parse(uri.path.substring(1));
       return proxy[index];
     };
 
     for (int i = 0; i < proxy.length; i++) {
-      client.getUrl(Uri.parse("http://127.0.0.1:${server.port}/$i"))
+      client.getUrl(Uri.parse("http://localhost:${server.port}/$i"))
         .then((HttpClientRequest clientRequest) {
           String content = "$i$i$i";
           clientRequest.contentLength = content.length;
           clientRequest.write(content);
           return clientRequest.close();
         })
         .then((HttpClientResponse response) {
           response.listen((_) {}, onDone: () {
             if (++testRealProxyDoneCount == proxy.length) {
               Expect.equals(proxy.length, server.requestCount);
@@ skipping 17 matching lines @@
          "PROXY hede.hule.hest:8080; PROXY test:test@localhost:8080",
          "PROXY test:test@localhost:8080; DIRECT"];
 
     client.findProxy = (Uri uri) {
       // Pick the proxy configuration based on the request path.
       int index = int.parse(uri.path.substring(1));
       return proxy[index];
     };
 
     for (int i = 0; i < proxy.length; i++) {
-      client.getUrl(Uri.parse("http://127.0.0.1:${server.port}/$i"))
+      client.getUrl(Uri.parse("http://localhost:${server.port}/$i"))
         .then((HttpClientRequest clientRequest) {
           String content = "$i$i$i";
           clientRequest.contentLength = content.length;
           clientRequest.write(content);
           return clientRequest.close();
         })
         .then((HttpClientResponse response) {
           response.listen((_) {}, onDone: () {
             if (++testRealProxyAuthDoneCount == proxy.length) {
               Expect.equals(proxy.length, server.requestCount);
@@ skipping 19 matching lines @@
   testDirectProxy();
   testProxy();
   testProxyChain();
   testProxyFromEnviroment();
   testProxyAuthenticate();
   // This test is not normally run. It can be used for locally testing
   // with a real proxy server (e.g. Apache).
   //testRealProxy();
   //testRealProxyAuth();
 }