Allow optional callStack argument to Future.completeException().

tests/corelib/future_test.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.
 
 // Tests for Future.immediate
 
 testImmediate() {
   final future = new Future<String>.immediate("42");
   Expect.isTrue(future.isComplete);
   Expect.isTrue(future.hasValue);
@@ skipping 188 matching lines @@
 }
 
 // Tests for [handleException]
 
 testException() {
   final completer = new Completer<int>();
   final future = completer.future;
   final ex = new Exception();
   future.then((_) {}); // exception is thrown if we plan to use the value
   Expect.throws(
-      () { completer.completeException(ex); }, 
+      () { completer.completeException(ex); },
       check: (e) => e == ex);
 }
 
 testExceptionNoSuccessListeners() {
   final completer = new Completer<int>();
   final future = completer.future;
   final ex = new Exception();
   completer.completeException(ex); // future.then is not called, so no exception
 }
 
@@ skipping 35 matching lines @@
 testExceptionHandlerReturnsFalse() {
   final completer = new Completer<int>();
   final future = completer.future;
   final ex = new Exception();
 
   bool reached = false;
   future.then((_) {}); // ensure exception is thrown...
   future.handleException((e) { return false; });
   future.handleException((e) { reached = true; return false; }); // overshadowed
   Expect.throws(
-      () { completer.completeException(ex); }, 
+      () { completer.completeException(ex); },
       check: (e) => e == ex);
   Expect.isTrue(reached);
 }
 
 testExceptionHandlerReturnsFalse2() {
   final completer = new Completer<int>();
   final future = completer.future;
   final ex = new Exception();
 
   bool reached = false;
@@ skipping 20 matching lines @@
   final future = completer.future;
   final ex = new Exception();
 
   var ex2;
   completer.completeException(ex);
   future.handleException((e) { ex2 = e; return false; });
   Expect.throws(() { future.then((e) { }); });
   Expect.equals(ex, ex2);
 }
 
+// Tests for accessing the exception call stack.
+
+testCallStackThrowsIfNotComplete() {
+  var exception;
+  try {
+    new Completer().future.callStack;
+  } catch (var ex) {
+    exception = ex;
+  }
+
+  Expect.isTrue(exception is FutureNotCompleteException);
+}
+
+testCallStackIsNullIfCompletedSuccessfully() {
+  Expect.isNull(new Future.immediate('blah').callStack);
+}
+
+testCallStackReturnsCallstackPassedToCompleteException() {
+  final completer = new Completer();
+  final future = completer.future;
+
+  final callstack = 'fake call stack';
+  completer.completeException(new Exception(), callstack);
+  Expect.equals(callstack, future.callStack);
+}
+
+testCallStackIsCapturedIfTransformCallbackThrows() {
+  final completer = new Completer();
+  final transformed = completer.future.transform((_) {
+    throw 'whoops!';
+  });
+
+  final callstack = 'fake call stack';
+  completer.complete('blah');
+  Expect.isNotNull(transformed.callStack);
+}
+
+testCallStackIsCapturedIfChainCallbackThrows() {
+  final completer = new Completer();
+  final chained = completer.future.chain((_) {
+    throw 'whoops!';
+  });
+
+  final callstack = 'fake call stack';
+  completer.complete('blah');
+  Expect.isNotNull(chained.callStack);
+}
+
 // Tests for mixed usage of [onComplete], [then], and [handleException]
 
 testCompleteWithCompletionAndSuccessHandlers() {
   final completer = new Completer<int>();
   final future = completer.future;
 
   var valueFromSuccessHandler;
   var valueFromCompletionHandler;
   future.onComplete((f) {
     Expect.isNotNull(valueFromSuccessHandler);
@@ skipping 147 matching lines @@
   testCompleteWithSuccessHandlerAfterComplete();
   testCompleteManySuccessHandlers();
   testException();
   testExceptionHandler();
   testExceptionHandlerReturnsTrue();
   testExceptionHandlerReturnsTrue2();
   testExceptionHandlerReturnsFalse();
   testExceptionHandlerReturnsFalse2();
   testExceptionHandlerAfterCompleteThenNotCalled();
   testExceptionHandlerAfterCompleteReturnsFalseThenThrows();
+  testCallStackThrowsIfNotComplete();
+  testCallStackIsNullIfCompletedSuccessfully();
+  testCallStackReturnsCallstackPassedToCompleteException();
+  testCallStackIsCapturedIfTransformCallbackThrows();
+  testCallStackIsCapturedIfChainCallbackThrows();
   testCompleteWithCompletionAndSuccessHandlers();
   testExceptionWithCompletionAndSuccessHandlers();
   testExceptionWithCompletionAndSuccessAndExceptionHandlers();
   testTransformSuccess();
   testTransformFutureFails();
   testTransformTransformerFails();
   testChainSuccess();
   testChainFirstFutureFails();
   testChainTransformerFails();
   testChainSecondFutureFails();
 }