Update all Angular libs (run update_all.sh).

third_party/pkg/angular/lib/mock/zone.dart

 library angular.mock_zone;
 
 import 'dart:async' as dart_async;
 
+// async and sync are function compositions.
+class FunctionComposition {
+  Function outer;
+  Function inner;
+
+  FunctionComposition(this.outer, this.inner);
+
+  call() => outer(inner)();
+}
+
 final _asyncQueue = <Function>[];
 final _timerQueue = <_TimerSpec>[];
 final _asyncErrors = [];
 bool _noMoreAsync = false;
 
 /**
- * Runs any queued up async calls and any async calls queued with
- * running microLeap. Example:
+ * Processes the asynchronous queue established by [async].
+ *
+ * [microLeap] will process all items in the asynchronous queue,
+ * including new items queued during its execution. It will re-raise
+ * any exceptions that occur.
+ *
+ * NOTE: [microLeap] can only be used in [async] tests.
+ *
+ * Example:
  *
  *     it('should run async code', async(() {
  *       var thenRan = false;
  *       new Future.value('s').then((_) { thenRan = true; });
  *       expect(thenRan).toBe(false);
  *       microLeap();
  *       expect(thenRan).toBe(true);
  *     }));
  *
  *     it('should run chained thens', async(() {
  *       var log = [];
  *       new Future.value('s')
  *         .then((_) { log.add('firstThen'); })
  *         .then((_) { log.add('2ndThen'); });
  *       expect(log.join(' ')).toEqual('');
  *       microLeap();
  *       expect(log.join(' ')).toEqual('firstThen 2ndThen');
  *     }));
  *
  */
 microLeap() {
-  while (!_asyncQueue.isEmpty) {
+  while (_asyncQueue.isNotEmpty) {
     // copy the queue as it may change.
     var toRun = new List.from(_asyncQueue);
     _asyncQueue.clear();
     // TODO: Support the case where multiple exceptions are thrown.
     // e.g. with a throwNextException() method.
     assert(_asyncErrors.isEmpty);
     toRun.forEach((fn) => fn());
     if (_asyncErrors.isNotEmpty) {
       var e = _asyncErrors.removeAt(0);
       throw ['Async error', e[0], e[1]];
     }
   }
 }
 
 /**
+ * Returns whether the async queue is empty.
+ */
+isAsyncQueueEmpty() => _asyncQueue.isEmpty;
+
+/**
  * Simulates a clock tick by running any scheduled timers. Can only be used
  * in [async] tests.Clock tick will call [microLeap] to process the microtask
  * queue before each timer callback.
  *
  * Note: microtasks scheduled form the last timer are not going to be processed.
  *
  * Example:
  *
  *     it('should run queued timer after sufficient clock ticks', async(() {
  *       bool timerRan = false;
@@ skipping 64 matching lines @@
  * Causes scheduleMicrotask calls to throw exceptions.
  *
  * This function is useful while debugging async tests: the exception
  * is thrown from the scheduleMicrotask call-site instead later in the test.
  */
 noMoreAsync() {
   _noMoreAsync = true;
 }
 
 /**
- * Captures all scheduleMicrotask calls inside of a function.
+ * Captures all scheduleMicrotask calls and newly created Timers
+ * inside of a function.
+ *
+ * [async] will raise an exception if there are still active Timers
+ * when the function completes.
+ *
+ * Use [clockTick] to process timers, and [microLeap] to process
+ * scheduleMicrotask calls.
+ *
+ * NOTE: [async] will not return the result of [fn].
  *
  * Typically used within a test:
  *
  *     it('should be async', async(() {
  *       ...
  *     }));
  */
-async(Function fn) => () {
+async(Function fn) => new FunctionComposition(_asyncOuter, fn);
+
+_asyncOuter(Function fn) => () {
   _noMoreAsync = false;
   _asyncErrors.clear();
   _timerQueue.clear();
   var zoneSpec = new dart_async.ZoneSpecification(
       scheduleMicrotask: (_, __, ___, asyncFn) {
         if (_noMoreAsync) {
           throw ['scheduleMicrotask called after noMoreAsync()'];
         } else {
           _asyncQueue.add(asyncFn);
         }
@@ skipping 26 matching lines @@
 _createTimer(Function fn, Duration duration, bool periodic) {
   var timer = new _TimerSpec(fn, duration, periodic);
   _timerQueue.add(timer);
   return timer;
 }
 
 /**
  * Enforces synchronous code.  Any calls to scheduleMicrotask inside of 'sync'
  * will throw an exception.
  */
-sync(Function fn) => () {
+sync(Function fn) => new FunctionComposition(_syncOuter, fn);
+
+_syncOuter(Function fn) => () {
+  _asyncErrors.clear();
+
   dart_async.runZoned(fn, zoneSpecification: new dart_async.ZoneSpecification(
     scheduleMicrotask: (_, __, ___, asyncFn) {
         throw ['scheduleMicrotask called from sync function.'];
     },
     createTimer: (_, __, ____, Duration duration, void f()) {
         throw ['Timer created from sync function.'];
     },
     createPeriodicTimer:
         (_, __, ___, Duration period, void f(dart_async.Timer timer)) {
             throw ['periodic Timer created from sync function.'];
-        }
+        },
+    handleUncaughtError: (_, __, ___, e, s) => _asyncErrors.add([e, s])
     ));
+
+  _asyncErrors.forEach((e) {
+    throw "During runZoned: ${e[0]}.  Stack:\n${e[1]}";
+  });
 };
 
 class _TimerSpec implements dart_async.Timer {
   Function fn;
   Duration duration;
   Duration elapsed = Duration.ZERO;
   bool periodic;
   bool isActive = true;
 
   _TimerSpec(this.fn, this.duration, this.periodic);
 
   void cancel() {
     isActive = false;
   }
 }