Expose Zones.

tests/lib/async/zone_debug_test.dart

Index: tests/lib/async/zone_debug_test.dart
diff --git a/tests/lib/async/zone_debug_test.dart b/tests/lib/async/zone_debug_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..8283df08e0a224d6ffa0c18ed495cc85178c44d0
--- /dev/null
+++ b/tests/lib/async/zone_debug_test.dart
@@ -0,0 +1,129 @@
+// 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.
+
+import 'package:expect/expect.dart';
+import 'package:async_helper/async_helper.dart';
+import 'dart:async';
+
+import 'dart:collection';
+
+int stackTrace = 0;

[Lasse Reichstein Nielsen, 2013/09/23 14:24:12]

Name stackTraceCount would be easier to understand.
If that is what it is, otherwise a comment would be great.

[floitsch, 2013/09/23 17:12:07]

It stands for normal stack traces. So "count" would be wrong.
Added comment.

+List restoredStackTrace = [];
+
+List events = [];
+
+debugZoneRegisterCallback(Zone self, ZoneDelegate parent, Zone origin, f()) {
+  List savedTrace = [stackTrace]..addAll(restoredStackTrace);
+  return parent.registerCallback(origin, () {
+    restoredStackTrace = savedTrace;
+    return f();
+  });
+}
+
+debugZoneRegisterCallback1(Zone self, ZoneDelegate parent, Zone origin,
+                           f(arg)) {
+  List savedTrace = [stackTrace]..addAll(restoredStackTrace);
+  return parent.registerCallback(origin, (arg) {
+    restoredStackTrace = savedTrace;
+    return f(arg);
+  });
+}
+
+debugZoneRun(Zone self, ZoneDelegate parent, Zone origin, f()) {
+  stackTrace++;
+  restoredStackTrace = [];
+  return parent.run(origin, f);
+}
+
+debugZoneRun1(Zone self, ZoneDelegate parent, Zone origin, f(arg), arg) {
+  stackTrace++;
+  restoredStackTrace = [];
+  return parent.run1(origin, f, arg);
+}
+
+List expectedDebugTrace;
+
+debugUncaughtHandler(Zone self, ZoneDelegate parent, Zone origin, error) {
+  events.add("handling uncaught error $error");
+  Expect.listEquals(expectedDebugTrace, restoredStackTrace);
+  // Suppress the error and don't propagate to parent.
+}
+
+const DEBUG_DESCRIPTION = const ZoneDescription(
+    registerCallback: debugZoneRegisterCallback,
+    registerCallback1: debugZoneRegisterCallback1,
+    run: debugZoneRun,
+    run1: debugZoneRun1,
+    handleUncaughtError: debugUncaughtHandler);
+
+main() {
+  Completer done = new Completer();
+
+  // runGuarded calls run, captures the synchronous error (if any) and
+  // gives that one to handleUncaughtError.
+
+  Expect.identical(Zone.ROOT, Zone.current);
+  Zone forked;
+  forked = Zone.current.fork(null, DEBUG_DESCRIPTION);
+
+  asyncStart();
+
+  int openTests = 0;
+
+  openTests++;
+  forked.run(() {
+    int forkTrace = stackTrace;
+    runAsync(() {
+      int runAsyncTrace = stackTrace;
+      runAsync(() {
+        expectedDebugTrace = [runAsyncTrace, forkTrace];
+        openTests--;
+        if (openTests == 0) {
+          done.complete();
+        }
+        throw "foo";
+      });
+      expectedDebugTrace = [forkTrace];
+      throw "bar";
+    });
+  });
+
+  Expect.listEquals([], restoredStackTrace);
+  Zone forked2 = forked.fork();
+  Zone forked3 = forked2.fork();
+  int fork2Trace;
+  int fork3Trace;
+  var f2;
+  var globalTrace = stackTrace;
+  var f = forked3.bindCallback(() {
+    Expect.identical(forked3, Zone.current);
+    fork2Trace = stackTrace;
+    f2 = forked2.bindCallback(() {
+      Expect.identical(forked2, Zone.current);
+      Expect.listEquals([fork2Trace, globalTrace], restoredStackTrace);
+      fork3Trace = stackTrace;
+      openTests--;
+      if (openTests == 0) {
+        done.complete();
+      }
+      runAsync(() {
+        expectedDebugTrace = [fork3Trace, fork2Trace, globalTrace];
+        throw "gee";
+      });
+    }, runGuarded: false);
+  }, runGuarded: false);
+  openTests++;
+  f();
+  f2();
+
+  done.future.whenComplete(() {
+    // We don't really care for the order.
+    events.sort();
+    Expect.listEquals([ "handling uncaught error bar",
+                        "handling uncaught error foo",
+                        "handling uncaught error gee"],
+                      events);
+    asyncEnd();
+  });
+}