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 361 matching lines @@
 
   /// 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 = captureStackTraces ? new Trace.current() : null;
+    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";
-    }
+      if (captureStackTraces) {

[Bob Nystrom, 2013/04/30 23:05:36]

If capturing stack traces is fast enough now, how about removing this flag
entirely?

[nweiz, 2013/04/30 23:13:14]

Done.

+        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();

[Bob Nystrom, 2013/04/30 23:05:36]

Oh Dart and your awful function type syntax. You could just stick:

typedef T Fn<T>();

Somewhere in utils and be done with it. :)

[nweiz, 2013/04/30 23:13:14]

Currently we're using this once each in several different packages, so that
wouldn't save us anything.

+
+/// An identifier for an out-of-band callback running during a schedule.
+class PendingCallback {

[Bob Nystrom, 2013/04/30 23:05:36]

The fact that it's for an out-of-band callback isn't really relevant to the
class itself, is it? How about "Description" and then in the body document that
the class exists to lazily calculate the description for perf and stack trace
reasons?

[nweiz, 2013/04/30 23:13:14]

I'm more interested in being able to add more pending-callback-related
information here than I am in using it in other places that would require a lazy
description.

[Bob Nystrom, 2013/05/01 00:02:25]

In that case, keep the name of this type, but update the doc comments above to
remove "The descriptions of".

[nweiz, 2013/05/01 00:33:44]

That's specifically referring to the string, not the [PendingCallback] object.

+  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);
+}