Unit test changes:

utils/tests/pub/test_pub.dart

 // Copyright (c) 2012, 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.
 
 /// Test infrastructure for testing pub. Unlike typical unit tests, most pub
 /// tests are integration tests that stage some stuff on the file system, run
 /// pub, and then validate the results. This library provides an API to build
 /// tests like that.
 library test_pub;
 
@@ skipping 574 matching lines @@
             'Pub returned exit code ${result.exitCode}, expected $exitCode.');
       }
 
       if (failures.length > 0) {
         if (error == null) {
           // If we aren't validating the error, still show it on failure.
           failures.add('Pub stderr:');
           failures.addAll(result.stderr.map((line) => '| $line'));
         }
 
-        throw new ExpectException(failures.join('\n'));
+        throw new TestFailure(failures.join('\n'));
       }
 
       return null;
     });
   });
 }
 
 /// Starts a Pub process and returns a [ScheduledProcess] that supports
 /// interaction with that process.
 ///
@@ skipping 256 matching lines @@
 
   /// Validates that at least one file in [dir] matching [name] is valid
   /// according to [validate]. [validate] should throw or complete to an
   /// exception if the input path is invalid.
   Future _validateOneMatch(String dir, Future validate(String entry)) {
     // Special-case strings to support multi-level names like "myapp/packages".
     if (name is String) {
       var entry = path.join(dir, name);
       return defer(() {
         if (!entryExists(entry)) {
-          throw new ExpectException('Entry $entry not found.');
+          throw new TestFailure('Entry $entry not found.');
         }
         return validate(entry);
       });
     }
 
     // TODO(nweiz): remove this when issue 4061 is fixed.
     var stackTrace;
     try {
       throw "";
     } catch (_, localStackTrace) {
       stackTrace = localStackTrace;
     }
 
     return listDir(dir).then((files) {
       var matches = files.where((file) => endsWithPattern(file, name)).toList();
       if (matches.isEmpty) {
-        throw new ExpectException('No files in $dir match pattern $name.');
+        throw new TestFailure('No files in $dir match pattern $name.');
       }
       if (matches.length == 1) return validate(matches[0]);
 
       var failures = [];
       var successes = 0;
       var completer = new Completer();
       checkComplete() {
         if (failures.length + successes != matches.length) return;
         if (successes > 0) {
           completer.complete();
           return;
         }
 
         var error = new StringBuffer();
         error.add("No files named $name in $dir were valid:\n");
         for (var failure in failures) {
           error.add("  $failure\n");
         }
         completer.completeError(
-            new ExpectException(error.toString()), stackTrace);
+            new TestFailure(error.toString()), stackTrace);
       }
 
       for (var match in matches) {
         var future = validate(match).then((_) {
           successes++;
           checkComplete();
         }).catchError((e) {
           failures.add(e);
           checkComplete();
         });
@@ skipping 26 matching lines @@
   /// the deletion is done.
   Future delete(dir) =>
       defer(() => deleteFile(path.join(dir, _stringName)));
 
   /// Validates that this file correctly matches the actual file at [path].
   Future validate(String path) {
     return _validateOneMatch(path, (file) {
       var text = readTextFile(file);
       if (text == textContents) return null;
 
-      throw new ExpectException(
+      throw new TestFailure(
           'File $file should contain:\n\n$textContents\n\n'
           'but contained:\n\n$text');
     });
   }
 
   /// Loads the contents of the file.
   ByteStream load(List<String> path) {
     if (!path.isEmpty) {
       throw "Can't load ${path.join('/')} from within $name: not a directory.";
     }
@@ skipping 209 matching lines @@
 /// A descriptor that validates that no file exists with the given name.
 class NothingDescriptor extends Descriptor {
   NothingDescriptor(String name) : super(name);
 
   Future create(dir) => new Future.immediate(null);
   Future delete(dir) => new Future.immediate(null);
 
   Future validate(String dir) {
     return defer(() {
       if (entryExists(path.join(dir, name))) {
-        throw new ExpectException('File $name in $dir should not exist.');
+        throw new TestFailure('File $name in $dir should not exist.');
       }
     });
   }
 
   ByteStream load(List<String> path) {
     if (path.isEmpty) {
       throw "Can't load the contents of $name: it doesn't exist.";
     } else {
       throw "Can't load ${path.join('/')} from within $name: $name doesn't "
         "exist.";
@@ skipping 156 matching lines @@
         // Sleep for half a second in case _endExpected is set in the next
         // scheduled event.
         return sleep(500).then((_) {
           if (_endExpected) {
             _exitCodeCompleter.complete(exitCode);
             return;
           }
 
           return _printStreams();
         }).then((_) {
-          registerException(new ExpectException("Process $name ended "
+          registerException(new TestFailure("Process $name ended "
               "earlier than scheduled with exit code $exitCode"));
         });
       }).catchError((e) => registerException(e.error, e.stackTrace));
     });
 
     _scheduleOnException((_) {
       if (_process == null) return;
 
       if (_exitCode == null) {
         print("\nKilling process $name prematurely.");
@@ skipping 260 matching lines @@
 /// calling [completion] is unnecessary.
 void expectLater(Future actual, matcher, {String reason,
     FailureHandler failureHandler, bool verbose: false}) {
   _schedule((_) {
     return actual.then((value) {
       expect(value, matcher, reason: reason, failureHandler: failureHandler,
           verbose: false);
     });
   });
 }