Change pub tests and pub local server to use ipV4 localhost by address.

pkg/scheduled_test/lib/scheduled_server.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.
 
 library scheduled_test.scheduled_server;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:io';
 
@@ skipping 20 matching lines @@
   /// complete once the schedule reaches the point where that handler was
   /// scheduled.
   final _handlers = new Queue<Handler>();
 
   /// The number of servers created. Used for auto-generating descriptions;
   static var _count = 0;
 
   ScheduledServer._(this._server, this.description);
 
   /// Creates a new server listening on an automatically-allocated port on
-  /// localhost. [description] is used to refer to the server in debugging
+  /// 127.0.0.1. [description] is used to refer to the server in debugging
   /// messages.
   factory ScheduledServer([String description]) {
     var id = _count++;
     if (description == null) description = 'scheduled server $id';
 
     var scheduledServer;
     scheduledServer = new ScheduledServer._(schedule(() {
-      return SafeHttpServer.bind("localhost", 0).then((server) {
+      return SafeHttpServer.bind("127.0.0.1", 0).then((server) {
         server.listen(scheduledServer._handleRequest,
             onError: (e) => currentSchedule.signalError(e));
         currentSchedule.onComplete.schedule(server.close);
         return server;
       });
     }, "starting '$description'"), description);
     return scheduledServer;
   }
 
   /// The port on which the server is listening.
   Future<int> get port => _server.then((s) => s.port);
 
   /// The base URL of the server, including its port.
-  Future<Uri> get url => port.then((p) => Uri.parse("http://localhost:$p"));
+  Future<Uri> get url => port.then((p) => Uri.parse("http://127.0.0.1:$p"));
 
   /// Schedules [handler] to handle a request to the server with [method] and
   /// [path]. The schedule will wait until an HTTP request is received. If that
   /// request doesn't have the expected [method] and [path], it will fail.
   /// Otherwise, it will run [fn]. If [fn] returns a [Future], the schedule will
   /// wait until that [Future] completes.
   ///
   /// The request must be received at the point in the schedule at which
   /// [handle] was called, or in the task immediately prior (to allow for
   /// non-deterministic asynchronicity). Otherwise, an error will be thrown.
@@ skipping 21 matching lines @@
              "when no more requests were expected.");
       }
       return _handlers.removeFirst().fn(request);
     }).catchError((e) {
       // Close the server so that we don't leave a dangling request.
       _server.then((s) => s.close());
       throw e;
     }), 'receiving ${request.method} ${request.uri}');
   }
 }