Add an error callback to StackZoneSpecification.

pkg/stack_trace/test/chain_test.dart

 // Copyright (c) 2013, 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 chain_test;
 
 import 'dart:async';
 
 import 'package:path/path.dart' as p;
 import 'package:stack_trace/stack_trace.dart';
@@ skipping 75 matching lines @@
         // is important; programmers expect stack trace memory consumption to be
         // O(depth of program), not O(length of program).
         expect(chain.traces, hasLength(2));
 
         expect(chain.traces[0].frames.first, frameMember(startsWith('main')));
         expect(chain.traces[1].frames,
             contains(frameMember(startsWith('inFutureChain'))));
       });
     });
 
+    test('thrown in new Future()', () {
+      return captureFuture(() => inNewFuture(() => throw 'error'))
+          .then((chain) {
+        expect(chain.traces, hasLength(3));
+        expect(chain.traces[0].frames.first, frameMember(startsWith('main')));
+
+        // The second trace is the one captured by
+        // [StackZoneSpecification.errorCallback]. Because that runs
+        // asynchronously within [new Future], it doesn't actually refer to the
+        // source file at all.
+        expect(chain.traces[1].frames,
+            everyElement(frameLibrary(isNot(contains('chain_test')))));
+
+        expect(chain.traces[2].frames,
+            contains(frameMember(startsWith('inNewFuture'))));
+      });
+    });
+
+    test('thrown in new Future.sync()', () {
+      return captureFuture(() {
+        inMicrotask(() => inSyncFuture(() => throw 'error'));
+      }).then((chain) {
+        expect(chain.traces, hasLength(3));
+        expect(chain.traces[0].frames.first, frameMember(startsWith('main')));
+        expect(chain.traces[1].frames,
+            contains(frameMember(startsWith('inSyncFuture'))));
+        expect(chain.traces[2].frames,
+            contains(frameMember(startsWith('inMicrotask'))));
+      });
+    });
+
     test('multiple times', () {
       var completer = new Completer();
       var first = true;
 
       Chain.capture(() {
         inMicrotask(() => throw 'first error');
         inPeriodicTimer(() => throw 'second error');
       }, onError: (error, chain) {
         try {
           if (first) {
             expect(error, equals('first error'));
             expect(chain.traces[1].frames,
                 contains(frameMember(startsWith('inMicrotask'))));
             first = false;
           } else {
             expect(error, equals('second error'));
             expect(chain.traces[1].frames,
                 contains(frameMember(startsWith('inPeriodicTimer'))));
             completer.complete();
           }
         } catch (error, stackTrace) {
           completer.completeError(error, stackTrace);
         }
       });
 
       return completer.future;
     });
 
+    test('passed to a completer', () {
+      var trace = new Trace.current();
+      return captureFuture(() {
+        inMicrotask(() => completerErrorFuture(trace));
+      }).then((chain) {
+        expect(chain.traces, hasLength(3));
+
+        // The first trace is the trace that was manually reported for the
+        // error.
+        expect(chain.traces.first.toString(), equals(trace.toString()));
+
+        // The second trace is the trace that was captured when
+        // [Completer.addError] was called.
+        expect(chain.traces[1].frames,
+            contains(frameMember(startsWith('completerErrorFuture'))));
+
+        // The third trace is the automatically-captured trace from when the
+        // microtask was scheduled.
+        expect(chain.traces[2].frames,
+            contains(frameMember(startsWith('inMicrotask'))));
+      });
+    });
+
+    test('passed to a completer with no stack trace', () {
+      return captureFuture(() {
+        inMicrotask(() => completerErrorFuture());
+      }).then((chain) {
+        expect(chain.traces, hasLength(2));
+
+        // The first trace is the one captured when [Completer.addError] was
+        // called.
+        expect(chain.traces[0].frames,
+            contains(frameMember(startsWith('completerErrorFuture'))));
+
+        // The second trace is the automatically-captured trace from when the
+        // microtask was scheduled.
+        expect(chain.traces[1].frames,
+            contains(frameMember(startsWith('inMicrotask'))));
+      });
+    });
+
+    test('passed to a stream controller', () {
+      var trace = new Trace.current();
+      return captureFuture(() {
+        inMicrotask(() => controllerErrorStream(trace).listen(null));
+      }).then((chain) {
+        expect(chain.traces, hasLength(3));
+        expect(chain.traces.first.toString(), equals(trace.toString()));
+        expect(chain.traces[1].frames,
+            contains(frameMember(startsWith('controllerErrorStream'))));
+        expect(chain.traces[2].frames,
+            contains(frameMember(startsWith('inMicrotask'))));
+      });
+    });
+
+    test('passed to a stream controller with no stack trace', () {
+      return captureFuture(() {
+        inMicrotask(() => controllerErrorStream().listen(null));
+      }).then((chain) {
+        expect(chain.traces, hasLength(2));
+        expect(chain.traces[0].frames,
+            contains(frameMember(startsWith('controllerErrorStream'))));
+        expect(chain.traces[1].frames,
+            contains(frameMember(startsWith('inMicrotask'))));
+      });
+    });
+
     test('and relays them to the parent zone', () {
       var completer = new Completer();
 
       runZoned(() {
         Chain.capture(() {
           inMicrotask(() => throw 'error');
         }, onError: (error, chain) {
           expect(error, equals('error'));
           expect(chain.traces[1].frames,
               contains(frameMember(startsWith('inMicrotask'))));
@@ skipping 385 matching lines @@
     ]).toTrace();
 
     expect(trace.toString(), equals(
         '$userSlashCode 10:11  Foo.bar\n'
         'dart:core 10:11       Bar.baz\n'
         '$userSlashCode 10:11  Foo.bar\n'
         'dart:core 10:11       Bar.baz\n'));
   });
 
   group('Chain.track(Future)', () {
-    test('associates the current chain with a manually-reported exception with '
-        'a stack trace', () {
-      var trace = new Trace.current();
-      return captureFuture(() {
-        inMicrotask(() => trackedErrorFuture(trace));
-      }).then((chain) {
-        expect(chain.traces, hasLength(3));
-
-        // The first trace is the trace that was manually reported for the
-        // error.
-        expect(chain.traces.first.toString(), equals(trace.toString()));
-
-        // The second trace is the trace that was captured when [Chain.track]
-        // was called.
-        expect(chain.traces[1].frames.first,
-            frameMember(startsWith('trackedErrorFuture')));
-
-        // The third trace is the automatically-captured trace from when the
-        // microtask was scheduled.
-        expect(chain.traces[2].frames,
-            contains(frameMember(startsWith('inMicrotask'))));
-      });
-    });
-
-    test('associates the current chain with a manually-reported exception with '
-        'no stack trace', () {
-      return captureFuture(() {
-        inMicrotask(() => trackedErrorFuture());
-      }).then((chain) {
-        expect(chain.traces, hasLength(3));
-
-        // The first trace is the one captured by
-        // [StackZoneSpecification.trackFuture], which should contain only
-        // stack_trace and dart: frames.
-        expect(chain.traces.first.frames,
-            everyElement(frameLibrary(isNot(contains('chain_test')))));
-
-        expect(chain.traces[1].frames.first,
-            frameMember(startsWith('trackedErrorFuture')));
-        expect(chain.traces[2].frames,
-            contains(frameMember(startsWith('inMicrotask'))));
-      });
-    });
-
     test('forwards the future value within Chain.capture()', () {
       Chain.capture(() {
         expect(Chain.track(new Future.value('value')),
             completion(equals('value')));
 
         var trace = new Trace.current();
         expect(Chain.track(new Future.error('error', trace))
             .catchError((e, stackTrace) {
           expect(e, equals('error'));
           expect(stackTrace.toString(), equals(trace.toString()));
         }), completes);
       });
     });
 
     test('forwards the future value outside of Chain.capture()', () {
       expect(Chain.track(new Future.value('value')),
           completion(equals('value')));
 
       var trace = new Trace.current();
       expect(Chain.track(new Future.error('error', trace))
           .catchError((e, stackTrace) {
         expect(e, equals('error'));
         expect(stackTrace.toString(), equals(trace.toString()));
       }), completes);
     });
   });
 
   group('Chain.track(Stream)', () {
-    test('associates the current chain with a manually-reported exception with '
-        'a stack trace', () {
-      var trace = new Trace.current();
-      return captureFuture(() {
-        inMicrotask(() => trackedErrorStream(trace).listen(null));
-      }).then((chain) {
-        expect(chain.traces, hasLength(3));
-        expect(chain.traces.first.toString(), equals(trace.toString()));
-        expect(chain.traces[1].frames.first,
-            frameMember(startsWith('trackedErrorStream')));
-        expect(chain.traces[2].frames,
-            contains(frameMember(startsWith('inMicrotask'))));
-      });
-    });
-
-    test('associates the current chain with a manually-reported exception with '
-        'no stack trace', () {
-      return captureFuture(() {
-        inMicrotask(() => trackedErrorStream().listen(null));
-      }).then((chain) {
-        expect(chain.traces, hasLength(3));
-        expect(chain.traces.first.frames,
-            everyElement(frameLibrary(isNot(contains('chain_test')))));
-        expect(chain.traces[1].frames.first,
-            frameMember(startsWith('trackedErrorStream')));
-        expect(chain.traces[2].frames,
-            contains(frameMember(startsWith('inMicrotask'))));
-      });
-    });
-
     test('forwards stream values within Chain.capture()', () {
       Chain.capture(() {
         var controller = new StreamController()
             ..add(1)..add(2)..add(3)..close();
         expect(Chain.track(controller.stream).toList(),
             completion(equals([1, 2, 3])));
 
         var trace = new Trace.current();
         controller = new StreamController()..addError('error', trace);
         expect(Chain.track(controller.stream).toList()
@@ skipping 44 matching lines @@
 void inFutureChain(callback()) {
   new Future(() {})
       .then((_) => new Future(() {}))
       .then((_) => new Future(() {}))
       .then((_) => new Future(() {}))
       .then((_) => new Future(() {}))
       .then((_) => callback())
       .then((_) => new Future(() {}));
 }
 
-/// Returns a Future that completes to an error and is wrapped in [Chain.track].
+void inNewFuture(callback()) {
+  new Future(callback);
+}
+
+void inSyncFuture(callback()) {
+  new Future.sync(callback);
+}
+
+/// Returns a Future that completes to an error using a completer.
 ///
 /// If [trace] is passed, it's used as the stack trace for the error.
-Future trackedErrorFuture([StackTrace trace]) {
+Future completerErrorFuture([StackTrace trace]) {
   var completer = new Completer();
   completer.completeError('error', trace);
-  return Chain.track(completer.future);
+  return completer.future;
 }
 
-/// Returns a Stream that emits an error and is wrapped in [Chain.track].
+/// Returns a Stream that emits an error using a controller.
 ///
 /// If [trace] is passed, it's used as the stack trace for the error.
-Stream trackedErrorStream([StackTrace trace]) {
+Stream controllerErrorStream([StackTrace trace]) {
   var controller = new StreamController();
   controller.addError('error', trace);
-  return Chain.track(controller.stream);
+  return controller.stream;
 }
 
 /// Runs [callback] within [asyncFn], then converts any errors raised into a
 /// [Chain] with [Chain.forTrace].
 Future<Chain> chainForTrace(asyncFn(callback()), callback()) {
   var completer = new Completer();
   asyncFn(() {
     // We use `new Future.value().then(...)` here as opposed to [new Future] or
     // [new Future.sync] because those methods don't pass the exception through
     // the zone specification before propagating it, so there's no chance to
@@ skipping 10 matching lines @@
 ///
 /// [callback] is expected to throw the string `"error"`.
 Future<Chain> captureFuture(callback()) {
   var completer = new Completer<Chain>();
   Chain.capture(callback, onError: (error, chain) {
     expect(error, equals('error'));
     completer.complete(chain);
   });
   return completer.future;
 }