Always capture stack traces when running pub tests.

pkg/scheduled_test/lib/src/schedule.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 schedule;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:stack_trace/stack_trace.dart';
@@ skipping 93 matching lines @@
   Duration get timeout => _timeout;
   Duration _timeout = new Duration(seconds: 5);
   set timeout(Duration duration) {
     _timeout = duration;
     heartbeat();
   }
 
   /// The timer for keeping track of task timeouts. This may be null.
   Timer _timeoutTimer;
 
-  /// If `true`, then new [Task]s will capture the current stack trace before
-  /// running. This can be set to `false` to speed up running tests since
-  /// capturing stack traces is currently quite slow. Even when set to `false`,
-  /// stack traces from *thrown* exceptions will be caught. This only disables
-  /// the eager collection of stack traces *before* an error occurs. Defaults
-  /// to `true`.
-  bool captureStackTraces = true;
-
   /// Creates a new schedule with empty task queues.
   Schedule() {
     _tasks = new TaskQueue._("tasks", this);
     _onComplete = new TaskQueue._("onComplete", this);
     _onException = new TaskQueue._("onException", this);
     _currentQueue = _tasks;
 
     heartbeat();
   }
 
@@ skipping 215 matching lines @@
 
 /// A queue of asynchronous tasks to execute in order.
 class TaskQueue {
   /// The tasks in the queue.
   List<Task> get contents => new UnmodifiableListView<Task>(_contents);
   final _contents = new Queue<Task>();
 
   /// The name of the queue, for debugging purposes.
   final String name;
 
-  /// If `true`, then new [Task]s in this queue will capture the current stack
-  /// trace before running.
-  bool get captureStackTraces => _schedule.captureStackTraces;
-
   /// The [Schedule] that created this queue.
   final Schedule _schedule;
 
   /// An out-of-band error signaled by [_schedule]. If this is non-null, it
   /// indicates that the queue should stop as soon as possible and re-throw this
   /// error.
   ScheduleError _error;
 
   /// The [SubstituteFuture] for the currently-running task in the queue, or
   /// null if no task is currently running.
   SubstituteFuture _taskFuture;
 
   /// The toal number of out-of-band callbacks that have been registered on
   /// [this].
   int _totalCallbacks = 0;
 
   /// Whether to stop running after the current task.
   bool _aborted = false;
 
   /// The descriptions of all callbacks that are blocking the completion of
   /// [this].
-  List<String> get pendingCallbacks =>
-      new UnmodifiableListView<String>(_pendingCallbacks);
-  final _pendingCallbacks = new Queue<String>();
+  List<PendingCallback> get pendingCallbacks =>
+      new UnmodifiableListView<PendingCallback>(_pendingCallbacks);
+  final _pendingCallbacks = new Queue<PendingCallback>();
 
   /// A completer that will be completed once [_pendingCallbacks] becomes empty
   /// after the queue finishes running its tasks.
   Future get _noPendingCallbacks => _noPendingCallbacksCompleter.future;
   final Completer _noPendingCallbacksCompleter = new Completer();
 
   /// A [Future] that completes when the tasks in [this] are all complete. If an
   /// error occurs while running this queue, the returned [Future] will complete
   /// with that error.
   ///
@@ skipping 103 matching lines @@
   /// chain. This will also block [this] from completing until the returned
   /// function has been called. It's used to ensure that out-of-band callbacks
   /// are properly handled by the scheduled test.
   Function _wrapAsync(fn(arg), String description) {
     assert(_schedule.state == ScheduleState.SET_UP || isRunning);
 
     // It's possible that the queue timed out before [fn] finished.
     bool _timedOut() =>
       _schedule.currentQueue != this || pendingCallbacks.isEmpty;
 
-    if (description == null) {
-      description = "Out-of-band operation #${_totalCallbacks}";
-    }
+    _totalCallbacks++;
+    var trace = new Trace.current();
+    var pendingCallback = new PendingCallback._(() {
+      var fullDescription = description;
+      if (fullDescription == null) {
+        fullDescription = "Out-of-band operation #${_totalCallbacks}";
+      }
 
-    if (captureStackTraces) {
-      var stackString = prefixLines(terseTraceString(new Trace.current()));
-      description += "\n\nStack trace:\n$stackString";
-    }
+      var stackString = prefixLines(terseTraceString(trace));
+      fullDescription += "\n\nStack trace:\n$stackString";
+    });
+    _pendingCallbacks.add(pendingCallback);
 
-    _totalCallbacks++;
-
-    _pendingCallbacks.add(description);
     return (arg) {
       try {
         return fn(arg);
       } catch (e, stackTrace) {
         var error = new ScheduleError.from(
             _schedule, e, stackTrace: stackTrace);
         if (_timedOut()) {
           _schedule._signalPostTimeoutError(error);
         } else {
           _schedule.signalError(error);
         }
       } finally {
         if (_timedOut()) return;
 
-        _pendingCallbacks.remove(description);
+        _pendingCallbacks.remove(pendingCallback);
         if (_pendingCallbacks.isEmpty && !isRunningTasks) {
           _noPendingCallbacksCompleter.complete();
         }
       }
     };
   }
 
   /// Signals that an out-of-band error has been detected and the queue should
   /// stop running as soon as possible.
   void _signalError(ScheduleError error) {
@@ skipping 53 matching lines @@
           return prefixLines(childString,
               firstPrefix: "  $prefix ", prefix: "  | ");
         }).join('\n');
         taskString = '$taskString\n$childrenString';
       }
 
       return taskString;
     }).join("\n");
   }
 }
+
+/// A thunk for lazily resolving the description of a [PendingCallback].
+typedef String _DescriptionThunk();
+
+/// An identifier for an out-of-band callback running during a schedule.
+class PendingCallback {
+  final _DescriptionThunk _thunk;
+  String _description;
+
+  /// The string description of the callback.
+  String get description {
+    if (_description == null) _description = _thunk();
+    return _description;
+  }
+
+  String toString() => description;
+
+  PendingCallback._(this._thunk);
+}