Replace the existing unittest APIs with the new runner infrastructure.

lib/src/loader.dart

 // Copyright (c) 2015, 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 unittest.loader;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
 
 import 'package:path/path.dart' as p;
 
 import 'dart.dart';
 import 'isolate_test.dart';
+import 'load_exception.dart';
+import 'remote_exception.dart';
 import 'suite.dart';
 
 /// A class for finding test files and loading them into a runnable form.
 class Loader {
   /// The package root to use for loading tests, or `null` to use the automatic
   /// root.
   final String _packageRoot;
 
   /// All isolates that have been spun up by the loader.
   final _isolates = new Set<Isolate>();
@@ skipping 17 matching lines @@
       if (p.split(entry.path).contains('packages')) return new Future.value();
 
       // TODO(nweiz): Provide a way for the caller to gracefully handle some
       // isolates failing to load without stopping the rest.
       return loadFile(entry.path);
     })).then((suites) => suites.toSet()..remove(null));
   }
 
   /// Loads a test suite from the file at [path].
   ///
-  /// This wil throw a [FileSystemException] if there's no `packages/` directory
-  /// available for [path]. Any other load error will cause an
-  /// [IsolateSpawnException] or a [RemoteException].
+  /// This will throw a [LoadException] if the file fails to load.
   Future<Suite> loadFile(String path) {
     // TODO(nweiz): Support browser tests.
     var packageRoot = _packageRoot == null
         ? p.join(p.dirname(path), 'packages')
         : _packageRoot;
 
     if (!new Directory(packageRoot).existsSync()) {
-      throw new FileSystemException("Directory $packageRoot does not exist.");
+      throw new LoadException(path, "Directory $packageRoot does not exist.");
     }
 
     var receivePort = new ReceivePort();
     return runInIsolate('''
 import "package:unittest/src/vm_listener.dart";
 
 import "${p.toUri(p.absolute(path))}" as test;
 
 void main(_, Map message) {
   var sendPort = message['reply'];
-  VmListener.start(sendPort, test.main);
+  VmListener.start(sendPort, () => test.main);
 }
 ''', {
       'reply': receivePort.sendPort
-    }, packageRoot: packageRoot).then((isolate) {
+    }, packageRoot: packageRoot).catchError((error, stackTrace) {
+      receivePort.close();
+      return new Future.error(new LoadException(path, error), stackTrace);
+    }).then((isolate) {
       _isolates.add(isolate);
       return receivePort.first;
-    }).then((tests) {
-      return new Suite(path, tests.map((test) {
+    }).then((response) {
+      if (response["type"] == "loadException") {
+        return new Future.error(new LoadException(path, response["message"]));
+      } else if (response["type"] == "error") {
+        var asyncError = RemoteException.deserialize(response["error"]);
+        return new Future.error(
+            new LoadException(path, asyncError.error),
+            asyncError.stackTrace);
+      }
+
+      return new Suite(path, response["tests"].map((test) {
         return new IsolateTest(test['name'], test['sendPort']);
       }));
     });
   }
 
   /// Closes the loader and releases all resources allocated by it.
   Future close() {
     for (var isolate in _isolates) {
       isolate.kill();
     }
     _isolates.clear();
     return new Future.value();
   }
 }