Normalize handling of the package root in the runner.

lib/src/runner/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 test.runner.loader;
 
 import 'dart:async';
 import 'dart:io';
 import 'dart:isolate';
 
@@ skipping 17 matching lines @@
 class Loader {
   /// All platforms for which tests should be loaded.
   final List<TestPlatform> _platforms;
 
   /// Whether to enable colors for Dart compilation.
   final bool _color;
 
   /// The root directory that will be served for browser tests.
   final String _root;
 
-  /// The package root to use for loading tests, or `null` to use the automatic
-  /// root.
+  /// The package root to use for loading tests.
   final String _packageRoot;
 
   /// The URL for the `pub serve` instance to use to load tests.
   ///
   /// This is `null` if tests should be loaded from the filesystem.
   final Uri _pubServeUrl;
 
   /// All isolates that have been spun up by the loader.
   final _isolates = new Set<Isolate>();
 
@@ skipping 14 matching lines @@
     return _browserServerCompleter.future;
   }
   Completer<BrowserServer> _browserServerCompleter;
 
   /// Creates a new loader.
   ///
   /// [root] is the root directory that will be served for browser tests. It
   /// defaults to the working directory.
   ///
   /// If [packageRoot] is passed, it's used as the package root for all loaded
-  /// tests. Otherwise, the `packages/` directories next to the test entrypoints
-  /// will be used.
+  /// tests. Otherwise, it's inferred from [root].
   ///
   /// If [pubServeUrl] is passed, tests will be loaded from the `pub serve`
   /// instance at that URL rather than from the filesystem.
   ///
   /// If [color] is true, console colors will be used when compiling Dart.
+  ///
+  /// If the package root doesn't exist, throws an [ApplicationException].
   Loader(Iterable<TestPlatform> platforms, {String root, String packageRoot,
         Uri pubServeUrl, bool color: false})
       : _platforms = platforms.toList(),
         _pubServeUrl = pubServeUrl,
         _root = root == null ? p.current : root,
-        _packageRoot = packageRoot,
+        _packageRoot = packageRootFor(root, packageRoot),
         _color = color;
 
   /// Loads all test suites in [dir].
   ///
   /// This will load tests from files that end in "_test.dart". Any tests that
   /// fail to load will be emitted as [LoadException]s.
   Stream<Suite> loadDir(String dir) {
     return mergeStreams(new Directory(dir).listSync(recursive: true)
         .map((entry) {
       if (entry is! File) return new Stream.fromIterable([]);
@@ skipping 52 matching lines @@
     return controller.stream;
   }
 
   /// Load the test suite at [path] in a browser.
   Future<Suite> _loadBrowserFile(String path, TestPlatform platform) =>
       _browserServer.then((browserServer) =>
           browserServer.loadSuite(path, platform));
 
   /// Load the test suite at [path] in VM isolate.
   Future<Suite> _loadVmFile(String path) {
-    var packageRoot = packageRootFor(path, _packageRoot);
     var receivePort = new ReceivePort();
 
     return new Future.sync(() {
       if (_pubServeUrl != null) {
         var url = _pubServeUrl.resolve(
             p.relative(path, from: 'test') + '.vm_test.dart');
         return Isolate.spawnUri(url, [], {'reply': receivePort.sendPort})
             .then((isolate) => new IsolateWrapper(isolate, () {}))
             .catchError((error, stackTrace) {
           if (error is! IsolateSpawnException) throw error;
@@ skipping 15 matching lines @@
 import "package:test/src/runner/vm/isolate_listener.dart";
 
 import "${p.toUri(p.absolute(path))}" as test;
 
 void main(_, Map message) {
   var sendPort = message['reply'];
   IsolateListener.start(sendPort, () => test.main);
 }
 ''', {
           'reply': receivePort.sendPort
-        }, packageRoot: packageRoot);
+        }, packageRoot: _packageRoot);
       }
     }).catchError((error, stackTrace) {
       receivePort.close();
       if (error is LoadException) throw error;
       return new Future.error(new LoadException(path, error), stackTrace);
     }).then((isolate) {
       _isolates.add(isolate);
       return receivePort.first;
     }).then((response) {
       if (response["type"] == "loadException") {
@@ skipping 16 matching lines @@
   Future close() {
     for (var isolate in _isolates) {
       isolate.kill();
     }
     _isolates.clear();
 
     if (_browserServerCompleter == null) return new Future.value();
     return _browserServer.then((browserServer) => browserServer.close());
   }
 }