Bind to all available loopback addresses in pub.

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';
 
+import 'package:http_multi_server/http_multi_server.dart';
 import 'package:shelf/shelf.dart' as shelf;
 import 'package:shelf/shelf_io.dart' as shelf_io;
 
 import 'scheduled_test.dart';
 import 'src/scheduled_server/handler.dart';
 import 'src/utils.dart';
 
 /// A class representing an HTTP server that's scheduled to run in the course of
 /// the test. This class allows the server's request handling to be scheduled
 /// synchronously.
@@ skipping 11 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
-  /// 127.0.0.1. [description] is used to refer to the server in debugging
-  /// messages.
+  /// localhost (both IPv4 and IPv6, if available).
+  ///
+  /// [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 shelf_io.serve(scheduledServer._handleRequest, "127.0.0.1", 0)
-          .then((server) {
+      return HttpMultiServer.loopback(0).then((server) {
+        shelf_io.serveRequests(server, scheduledServer._handleRequest);
         currentSchedule.onComplete.schedule(() => server.close(force: true));
         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://127.0.0.1:$p"));
+  Future<Uri> get url => port.then((p) => Uri.parse("http://localhost:$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 @@
     }), 'receiving ${request.method} ${request.url.path}').catchError((error) {
       // Don't let errors bubble up to the shelf handler. It will print them to
       // stderr, but the user will already be notified via the scheduled_test
       // infrastructure.
       return new shelf.Response.internalServerError(
           body: error.toString(),
           headers: {'content-type': 'text/plain'});
     });
   }
 }