Update the Angular/DI tests to latest from github.

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

 library angular.mock_zone;
 
 import 'dart:async' as dart_async;
 
-List<Function> _asyncQueue = [];
-List<_TimerSpec> _timerQueue = [];
-List _asyncErrors = [];
+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:
  *
  *     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) {
     // copy the queue as it may change.
     var toRun = new List.from(_asyncQueue);
-    _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.isEmpty) {
+    if (_asyncErrors.isNotEmpty) {
       var e = _asyncErrors.removeAt(0);
       throw ['Async error', e[0], e[1]];
     }
   }
 }
 
 /**
  * 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.
@@ skipping 17 matching lines @@
  *       new Timer.periodic(new Duration(milliseconds: 10), (_) => timerRan++);
  *
  *       clockTick(milliseconds: 9);
  *       expect(timerRan).toBe(0);
  *       clockTick(milliseconds: 1);
  *       expect(timerRan).toBe(1);
  *       clockTick(milliseconds: 30);
  *       expect(timerRan).toBe(4);
  *     }));
  */
-clockTick({int days: 0,
-    int hours: 0,
-    int minutes: 0,
-    int seconds: 0,
-    int milliseconds: 0,
-    int microseconds: 0}) {
+void clockTick({int days: 0,
+          int hours: 0,
+          int minutes: 0,
+          int seconds: 0,
+          int milliseconds: 0,
+          int microseconds: 0}) {
   var tickDuration = new Duration(days: days, hours: hours, minutes: minutes,
       seconds: seconds, milliseconds: milliseconds, microseconds: microseconds);
 
-  var queue = _timerQueue;
   var remainingTimers = [];
-  _timerQueue = [];
-  queue.forEach((_TimerSpec spec) {
-    if (!spec.isActive) return; // Skip over inactive timers.
-    if (spec.periodic) {
-      // We always add back the periodic timer unless it's cancelled.
-      remainingTimers.add(spec);
+  var queue = new List.from(_timerQueue);
+  _timerQueue.clear();
+  queue
+    .where((_TimerSpec spec) => spec.isActive)
+    .forEach((_TimerSpec spec) {
+      if (spec.periodic) {
+        // We always add back the periodic timer unless it's cancelled.
+        remainingTimers.add(spec);
 
-      // Ignore ZERO duration ticks for periodic timers.
-      if (tickDuration == Duration.ZERO) return;
+        // Ignore ZERO duration ticks for periodic timers.
+        if (tickDuration == Duration.ZERO) return;
 
-      spec.elapsed += tickDuration;
-      // Run the timer as many times as the timer priod fits into the tick.
-      while (spec.elapsed >= spec.duration) {
-        spec.elapsed -= spec.duration;
-        microLeap();
-        spec.fn(spec);
+        spec.elapsed += tickDuration;
+        // Run the timer as many times as the timer priod fits into the tick.
+        while (spec.elapsed >= spec.duration) {
+          spec.elapsed -= spec.duration;
+          microLeap();
+          spec.fn(spec);
+        }
+      } else {
+        spec.duration -= tickDuration;
+        if (spec.duration <= Duration.ZERO) {
+          microLeap();
+          spec.fn();
+        } else {
+          remainingTimers.add(spec);
+        }
       }
-    } else {
-      spec.duration -= tickDuration;
-      if (spec.duration <= Duration.ZERO) {
-        microLeap();
-        spec.fn();
-      } else {
-        remainingTimers.add(spec);
-      }
-    }
-  });
+    });
   // Remaining timers should come before anything else scheduled after them.
   _timerQueue.insertAll(0, remainingTimers);
 }
 
 /**
-* 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.
-*/
+ * 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.
  *
  * Typically used within a test:
  *
  *     it('should be async', async(() {
  *       ...
  *     }));
  */
-async(Function fn) =>
-    () {
+async(Function fn) => () {
   _noMoreAsync = false;
-  _asyncErrors = [];
-  _timerQueue = [];
+  _asyncErrors.clear();
+  _timerQueue.clear();
   var zoneSpec = new dart_async.ZoneSpecification(
       scheduleMicrotask: (_, __, ___, asyncFn) {
         if (_noMoreAsync) {
           throw ['scheduleMicrotask called after noMoreAsync()'];
         } else {
           _asyncQueue.add(asyncFn);
         }
       },
       createTimer: (_, __, ____, Duration duration, void f()) =>
           _createTimer(f, duration, false),
       createPeriodicTimer:
           (_, __, ___, Duration period, void f(dart_async.Timer timer)) =>
               _createTimer(f, period, true),
       handleUncaughtError: (_, __, ___, e, s) => _asyncErrors.add([e, s])
   );
   dart_async.runZoned(() {
       fn();
       microLeap();
     }, zoneSpecification: zoneSpec);
 
   _asyncErrors.forEach((e) {
     throw "During runZoned: ${e[0]}.  Stack:\n${e[1]}";
   });
 
-  if (!_timerQueue.isEmpty && _timerQueue.any((_TimerSpec spec) => spec.isActive)) {
-    throw ["${_timerQueue.where((_TimerSpec spec) => spec.isActive).length} "
-           "active timer(s) are still in the queue."];
+  var activeTimers = _timerQueue.fold(0, (nb, _TimerSpec spec) {
+    return spec.isActive ? nb + 1 : nb;
+  });
+
+  if (activeTimers > 0) {
+    throw ["$activeTimers active timer(s) are still in the queue."];
   }
 };
 
 _createTimer(Function fn, Duration duration, bool periodic) {
   var timer = new _TimerSpec(fn, duration, periodic);
   _timerQueue.add(timer);
   return timer;
 }
 
 /**
@@ skipping 21 matching lines @@
   Duration elapsed = Duration.ZERO;
   bool periodic;
   bool isActive = true;
 
   _TimerSpec(this.fn, this.duration, this.periodic);
 
   void cancel() {
     isActive = false;
   }
 }