More gracefully handle load errors.

test/runner/loader_test.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.
 
 @TestOn("vm")
 
 import 'dart:io';
 
 import 'package:path/path.dart' as p;
 import 'package:test/src/backend/state.dart';
@@ skipping 31 matching lines @@
     new Directory(_sandbox).deleteSync(recursive: true);
     return _loader.close();
   });
 
   group(".loadFile()", () {
     var suite;
     setUp(() {
       /// TODO(nweiz): Use scheduled_test for this once it's compatible with
       /// this version of test.
       new File(p.join(_sandbox, 'a_test.dart')).writeAsStringSync(_tests);
-      return _loader.loadFile(p.join(_sandbox, 'a_test.dart')).then((suites) {
+      return _loader.loadFile(p.join(_sandbox, 'a_test.dart')).toList()
+          .then((suites) {
         expect(suites, hasLength(1));
         suite = suites.first;
       });
     });
 
     test("returns a suite with the file path and platform", () {
       expect(suite.path, equals(p.join(_sandbox, 'a_test.dart')));
       expect(suite.platform, equals('VM'));
     });
 
@@ skipping 18 matching lines @@
 
     test("can load and run a failing test", () {
       var liveTest = suite.tests[1].load(suite);
       expectSingleFailure(liveTest);
       return liveTest.run().whenComplete(() => liveTest.close());
     });
 
     test("throws a nice error if the package root doesn't exist", () {
       var loader = new Loader([TestPlatform.vm]);
       expect(
-          loader.loadFile(p.join(_sandbox, 'a_test.dart'))
+          loader.loadFile(p.join(_sandbox, 'a_test.dart')).first
               .whenComplete(loader.close),
           throwsA(isLoadException(
               "Directory ${p.join(_sandbox, 'packages')} does not exist.")));
     });
   });
 
   group(".loadDir()", () {
     test("ignores non-Dart files", () {
       new File(p.join(_sandbox, 'a_test.txt')).writeAsStringSync(_tests);
-      expect(_loader.loadDir(_sandbox), completion(isEmpty));
+      expect(_loader.loadDir(_sandbox).toList(), completion(isEmpty));
     });
 
     test("ignores files in packages/ directories", () {
       var dir = p.join(_sandbox, 'packages');
       new Directory(dir).createSync();
       new File(p.join(dir, 'a_test.dart')).writeAsStringSync(_tests);
-      expect(_loader.loadDir(_sandbox), completion(isEmpty));
+      expect(_loader.loadDir(_sandbox).toList(), completion(isEmpty));
     });
 
     test("ignores files that don't end in _test.dart", () {
       new File(p.join(_sandbox, 'test.dart')).writeAsStringSync(_tests);
-      expect(_loader.loadDir(_sandbox), completion(isEmpty));
+      expect(_loader.loadDir(_sandbox).toList(), completion(isEmpty));
     });
 
     group("with suites loaded from a directory", () {
       var suites;
       setUp(() {
         /// TODO(nweiz): Use scheduled_test for this once it's compatible with
         /// this version of test.
         new File(p.join(_sandbox, 'a_test.dart')).writeAsStringSync(_tests);
         new File(p.join(_sandbox, 'another_test.dart'))
             .writeAsStringSync(_tests);
         new Directory(p.join(_sandbox, 'dir')).createSync();
         new File(p.join(_sandbox, 'dir/sub_test.dart'))
             .writeAsStringSync(_tests);
 
-        return _loader.loadDir(_sandbox).then((suites_) => suites = suites_);
+        return _loader.loadDir(_sandbox).toList()
+            .then((suites_) => suites = suites_);
       });
 
       test("gives those suites the correct paths", () {
         expect(suites.map((suite) => suite.path), unorderedEquals([
           p.join(_sandbox, 'a_test.dart'),
           p.join(_sandbox, 'another_test.dart'),
           p.join(_sandbox, 'dir/sub_test.dart')
         ]));
       });
 
       test("can run tests in those suites", () {
         var suite = suites.firstWhere((suite) => suite.path.contains("a_test"));
         var liveTest = suite.tests[1].load(suite);
         expectSingleFailure(liveTest);
         return liveTest.run().whenComplete(() => liveTest.close());
       });
     });
   });
 }