diff --git a/CHANGELOG.md b/CHANGELOG.md
index aa737e7..299d220 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,11 @@
 ## 0.12.5
 
+* Add `setUpAll()` and `tearDownAll()` methods that run callbacks before and
+  after all tests in a group or suite. **Note that these methods are for special
+  cases and should be avoided**—they make it very easy to accidentally introduce
+  dependencies between tests. Use `setUp()` and `tearDown()` instead if
+  possible.
+
 * Allow `setUp()` and `tearDown()` to be called multiple times within the same
   group.
 
diff --git a/lib/src/backend/declarer.dart b/lib/src/backend/declarer.dart
index f8dae47..46a52d9 100644
--- a/lib/src/backend/declarer.dart
+++ b/lib/src/backend/declarer.dart
@@ -9,9 +9,10 @@
 import '../frontend/timeout.dart';
 import '../utils.dart';
 import 'group.dart';
+import 'group_entry.dart';
 import 'invoker.dart';
 import 'metadata.dart';
-import 'group_entry.dart';
+import 'test.dart';
 
 /// A class that manages the state of tests as they're declared.
 ///
@@ -34,12 +35,18 @@
   /// and of the test suite.
   final Metadata _metadata;
 
-  /// The set-up functions for this group.
+  /// The set-up functions to run for each test in this group.
   final _setUps = new List<AsyncFunction>();
 
-  /// The tear-down functions for this group.
+  /// The tear-down functions to run for each test in this group.
   final _tearDowns = new List<AsyncFunction>();
 
+  /// The set-up functions to run once for this group.
+  final _setUpAlls = new List<AsyncFunction>();
+
+  /// The tear-down functions to run once for this group.
+  final _tearDownAlls = new List<AsyncFunction>();
+
   /// The children of this group, either tests or sub-groups.
   final _entries = new List<GroupEntry>();
 
@@ -67,9 +74,7 @@
   /// Defines a test case with the given name and body.
   void test(String name, body(), {String testOn, Timeout timeout, skip,
       Map<String, dynamic> onPlatform}) {
-    if (_built) {
-      throw new StateError("Can't call test() once tests have begun running.");
-    }
+    _checkNotBuilt("test");
 
     var metadata = _metadata.merge(new Metadata.parse(
         testOn: testOn, timeout: timeout, skip: skip, onPlatform: onPlatform));
@@ -90,9 +95,7 @@
   /// Creates a group of tests.
   void group(String name, void body(), {String testOn, Timeout timeout, skip,
       Map<String, dynamic> onPlatform}) {
-    if (_built) {
-      throw new StateError("Can't call group() once tests have begun running.");
-    }
+    _checkNotBuilt("group");
 
     var metadata = _metadata.merge(new Metadata.parse(
         testOn: testOn, timeout: timeout, skip: skip, onPlatform: onPlatform));
@@ -113,31 +116,45 @@
 
   /// Registers a function to be run before each test in this group.
   void setUp(callback()) {
-    if (_built) {
-      throw new StateError("Can't call setUp() once tests have begun running.");
-    }
-
+    _checkNotBuilt("setUp");
     _setUps.add(callback);
   }
 
   /// Registers a function to be run after each test in this group.
   void tearDown(callback()) {
-    if (_built) {
-      throw new StateError(
-          "Can't call tearDown() once tests have begun running.");
-    }
-
+    _checkNotBuilt("tearDown");
     _tearDowns.add(callback);
   }
 
+  /// Registers a function to be run once before all tests.
+  void setUpAll(callback()) {
+    _checkNotBuilt("setUpAll");
+    _setUpAlls.add(callback);
+  }
+
+  /// Registers a function to be run once after all tests.
+  void tearDownAll(callback()) {
+    _checkNotBuilt("tearDownAll");
+    _tearDownAlls.add(callback);
+  }
+
   /// Finalizes and returns the group being declared.
   Group build() {
-    if (_built) {
-      throw new StateError("Can't call Declarer.build() more than once.");
-    }
+    _checkNotBuilt("build");
 
     _built = true;
-    return new Group(_name, _entries.toList(), metadata: _metadata);
+    return new Group(_name, _entries.toList(),
+        metadata: _metadata,
+        setUpAll: _setUpAll,
+        tearDownAll: _tearDownAll);
+  }
+
+  /// Throws a [StateError] if [build] has been called.
+  ///
+  /// [name] should be the name of the method being called.
+  void _checkNotBuilt(String name) {
+    if (!_built) return;
+    throw new StateError("Can't call $name() once tests have begun running.");
   }
 
   /// Run the set-up functions for this and any parent groups.
@@ -173,6 +190,26 @@
     });
   }
 
+  /// Returns a [Test] that runs the callbacks in [_setUpAll].
+  Test get _setUpAll {
+    if (_setUpAlls.isEmpty) return null;
+
+    return new LocalTest(_prefix("(setUpAll)"), _metadata, () {
+      return Future.forEach(_setUpAlls, (setUp) => setUp());
+    });
+  }
+
+  /// Returns a [Test] that runs the callbacks in [_tearDownAll].
+  Test get _tearDownAll {
+    if (_tearDownAlls.isEmpty) return null;
+
+    return new LocalTest(_prefix("(tearDownAll)"), _metadata, () {
+      return Invoker.current.unclosable(() {
+        return Future.forEach(_tearDownAlls.reversed, _errorsDontStopTest);
+      });
+    });
+  }
+
   /// Runs [body] with special error-handling behavior.
   ///
   /// Errors emitted [body] will still cause the current test to fail, but they
diff --git a/lib/src/backend/group.dart b/lib/src/backend/group.dart
index bcc7e77..dc7e6bd 100644
--- a/lib/src/backend/group.dart
+++ b/lib/src/backend/group.dart
@@ -25,7 +25,18 @@
   Group.root(Iterable<GroupEntry> entries, {Metadata metadata})
       : this(null, entries, metadata: metadata);
 
-  Group(this.name, Iterable<GroupEntry> entries, {Metadata metadata})
+  /// A test to run before all tests in the group.
+  ///
+  /// This is `null` if no `setUpAll` callbacks were declared.
+  final Test setUpAll;
+
+  /// A test to run after all tests in the group.
+  ///
+  /// This is `null` if no `tearDown` callbacks were declared.
+  final Test tearDownAll;
+
+  Group(this.name, Iterable<GroupEntry> entries, {Metadata metadata,
+          Test this.setUpAll, Test this.tearDownAll})
       : entries = new List<GroupEntry>.unmodifiable(entries),
         metadata = metadata == null ? new Metadata() : metadata;
 
@@ -34,13 +45,15 @@
     var newMetadata = metadata.forPlatform(platform, os: os);
     var filtered = _map((entry) => entry.forPlatform(platform, os: os));
     if (filtered.isEmpty) return null;
-    return new Group(name, filtered, metadata: newMetadata);
+    return new Group(name, filtered,
+        metadata: newMetadata, setUpAll: setUpAll, tearDownAll: tearDownAll);
   }
 
   Group filter(bool callback(Test test)) {
     var filtered = _map((entry) => entry.filter(callback));
     if (filtered.isEmpty) return null;
-    return new Group(name, filtered, metadata: metadata);
+    return new Group(name, filtered,
+        metadata: metadata, setUpAll: setUpAll, tearDownAll: tearDownAll);
   }
 
   /// Returns the entries of this group mapped using [callback].
diff --git a/lib/src/runner/browser/browser_manager.dart b/lib/src/runner/browser/browser_manager.dart
index 925dddc..fc570d1 100644
--- a/lib/src/runner/browser/browser_manager.dart
+++ b/lib/src/runner/browser/browser_manager.dart
@@ -13,6 +13,7 @@
 
 import '../../backend/group.dart';
 import '../../backend/metadata.dart';
+import '../../backend/test.dart';
 import '../../backend/test_platform.dart';
 import '../../util/cancelable_future.dart';
 import '../../util/multi_channel.dart';
@@ -259,11 +260,25 @@
         return _deserializeGroup(suiteChannel, mapper, entry);
       }
 
-      var testMetadata = new Metadata.deserialize(entry['metadata']);
-      var testChannel = suiteChannel.virtualChannel(entry['channel']);
-      return new IframeTest(entry['name'], testMetadata, testChannel,
-          mapper: mapper);
-    }), metadata: metadata);
+      return _deserializeTest(suiteChannel, mapper, entry);
+    }),
+        metadata: metadata,
+        setUpAll: _deserializeTest(suiteChannel, mapper, group['setUpAll']),
+        tearDownAll:
+            _deserializeTest(suiteChannel, mapper, group['tearDownAll']));
+  }
+
+  /// Deserializes [test] into a concrete [Test] class.
+  ///
+  /// Returns `null` if [test] is `null`.
+  Test _deserializeTest(MultiChannel suiteChannel, StackTraceMapper mapper,
+      Map test) {
+    if (test == null) return null;
+
+    var metadata = new Metadata.deserialize(test['metadata']);
+    var testChannel = suiteChannel.virtualChannel(test['channel']);
+    return new IframeTest(test['name'], metadata, testChannel,
+        mapper: mapper);
   }
 
   /// An implementation of [Environment.displayPause].
diff --git a/lib/src/runner/browser/iframe_listener.dart b/lib/src/runner/browser/iframe_listener.dart
index 815a37e..834f3e1 100644
--- a/lib/src/runner/browser/iframe_listener.dart
+++ b/lib/src/runner/browser/iframe_listener.dart
@@ -131,32 +131,42 @@
     });
   }
 
-  /// Serializes [entries] into a JSON-safe map.
+  /// Serializes [group] into a JSON-safe map.
   Map _serializeGroup(MultiChannel channel, Group group) {
     return {
       "type": "group",
       "name": group.name,
       "metadata": group.metadata.serialize(),
+      "setUpAll": _serializeTest(channel, group.setUpAll),
+      "tearDownAll": _serializeTest(channel, group.tearDownAll),
       "entries": group.entries.map((entry) {
-        if (entry is Group) return _serializeGroup(channel, entry);
-
-        var test = entry as Test;
-        var testChannel = channel.virtualChannel();
-        testChannel.stream.listen((message) {
-          assert(message['command'] == 'run');
-          _runTest(test, channel.virtualChannel(message['channel']));
-        });
-
-        return {
-          "type": "test",
-          "name": test.name,
-          "metadata": test.metadata.serialize(),
-          "channel": testChannel.id
-        };
+        return entry is Group
+            ? _serializeGroup(channel, entry)
+            : _serializeTest(channel, entry);
       }).toList()
     };
   }
 
+  /// Serializes [test] into a JSON-safe map.
+  ///
+  /// Returns `null` if [test] is `null`.
+  Map _serializeTest(MultiChannel channel, Test test) {
+    if (test == null) return null;
+
+    var testChannel = channel.virtualChannel();
+    testChannel.stream.listen((message) {
+      assert(message['command'] == 'run');
+      _runTest(test, channel.virtualChannel(message['channel']));
+    });
+
+    return {
+      "type": "test",
+      "name": test.name,
+      "metadata": test.metadata.serialize(),
+      "channel": testChannel.id
+    };
+  }
+
   /// Runs [test] and sends the results across [channel].
   void _runTest(Test test, MultiChannel channel) {
     var liveTest = test.load(_suite);
diff --git a/lib/src/runner/engine.dart b/lib/src/runner/engine.dart
index 6bd51bf..ed88544 100644
--- a/lib/src/runner/engine.dart
+++ b/lib/src/runner/engine.dart
@@ -215,18 +215,35 @@
       return;
     }
 
-    for (var entry in group.entries) {
-      if (_closed) return;
+    var setUpAllSucceeded = true;
+    if (group.setUpAll != null) {
+      var liveTest = group.setUpAll.load(suite);
+      await _runLiveTest(liveTest, countSuccess: false);
+      setUpAllSucceeded = liveTest.state.result == Result.success;
+    }
 
-      if (entry is Group) {
-        await _runGroup(suite, entry);
-      } else if (entry.metadata.skip) {
-        await _runLiveTest(_skippedTest(suite, entry));
-      } else {
-        var test = entry as Test;
-        await _runLiveTest(test.load(suite));
+    if (!_closed && setUpAllSucceeded) {
+      for (var entry in group.entries) {
+        if (_closed) return;
+
+        if (entry is Group) {
+          await _runGroup(suite, entry);
+        } else if (entry.metadata.skip) {
+          await _runLiveTest(_skippedTest(suite, entry));
+        } else {
+          var test = entry as Test;
+          await _runLiveTest(test.load(suite));
+        }
       }
     }
+
+    // Even if we're closed or setUpAll failed, we want to run all the teardowns
+    // to ensure that any state is properly cleaned up.
+    if (group.tearDownAll != null) {
+      var liveTest = group.tearDownAll.load(suite);
+      await _runLiveTest(liveTest, countSuccess: false);
+      if (_closed) await liveTest.close();
+    }
   }
 
   /// Returns a dummy [LiveTest] for a test or group marked as "skip".
@@ -244,7 +261,10 @@
   }
 
   /// Runs [liveTest].
-  Future _runLiveTest(LiveTest liveTest) async {
+  ///
+  /// If [countSuccess] is `true` (the default), the test is put into [passed]
+  /// if it succeeds. Otherwise, it's removed from [liveTests] entirely.
+  Future _runLiveTest(LiveTest liveTest, {bool countSuccess: true}) async {
     _liveTests.add(liveTest);
     _active.add(liveTest);
 
@@ -270,8 +290,10 @@
         _failed.add(liveTest);
       } else if (liveTest.test.metadata.skip) {
         _skipped.add(liveTest);
-      } else {
+      } else if (countSuccess) {
         _passed.add(liveTest);
+      } else {
+        _liveTests.remove(liveTest);
       }
     });
 
@@ -342,15 +364,19 @@
   /// the engine indicates that no more output should be emitted.
   Future close() async {
     _closed = true;
-    if (_closedBeforeDone == null) _closedBeforeDone = true;
+    if (_closedBeforeDone != null) _closedBeforeDone = true;
     _suiteController.close();
 
     // Close the running tests first so that we're sure to wait for them to
     // finish before we close their suites and cause them to become unloaded.
     var allLiveTests = liveTests.toSet()..addAll(_activeLoadTests);
-    await Future.wait(allLiveTests.map((liveTest) => liveTest.close()));
+    var futures = allLiveTests.map((liveTest) => liveTest.close()).toList();
 
-    var allSuites = allLiveTests.map((liveTest) => liveTest.suite).toSet();
-    await Future.wait(allSuites.map((suite) => suite.close()));
+    // Closing the load pool will close the test suites as soon as their tests
+    // are done. For browser suites this is effectively immediate since their
+    // tests shut down as soon as they're closed, but for VM suites we may need
+    // to wait for tearDowns or tearDownAlls to run.
+    futures.add(_loadPool.close());
+    await Future.wait(futures, eagerError: true);
   }
 }
diff --git a/lib/src/runner/loader.dart b/lib/src/runner/loader.dart
index 1585078..62fb46b 100644
--- a/lib/src/runner/loader.dart
+++ b/lib/src/runner/loader.dart
@@ -15,6 +15,7 @@
 
 import '../backend/group.dart';
 import '../backend/metadata.dart';
+import '../backend/test.dart';
 import '../backend/test_platform.dart';
 import '../util/dart.dart' as dart;
 import '../util/io.dart';
@@ -244,9 +245,21 @@
     var metadata = new Metadata.deserialize(group['metadata']);
     return new Group(group['name'], group['entries'].map((entry) {
       if (entry['type'] == 'group') return _deserializeGroup(entry);
-      var testMetadata = new Metadata.deserialize(entry['metadata']);
-      return new IsolateTest(entry['name'], testMetadata, entry['sendPort']);
-    }), metadata: metadata);
+      return _deserializeTest(entry);
+    }),
+        metadata: metadata,
+        setUpAll: _deserializeTest(group['setUpAll']),
+        tearDownAll: _deserializeTest(group['tearDownAll']));
+  }
+
+  /// Deserializes [test] into a concrete [Test] class.
+  ///
+  /// Returns `null` if [test] is `null`.
+  Test _deserializeTest(Map test) {
+    if (test == null) return null;
+
+    var metadata = new Metadata.deserialize(test['metadata']);
+    return new IsolateTest(test['name'], metadata, test['sendPort']);
   }
 
   /// Closes the loader and releases all resources allocated by it.
diff --git a/lib/src/runner/vm/isolate_listener.dart b/lib/src/runner/vm/isolate_listener.dart
index 493ade4..23f7b73 100644
--- a/lib/src/runner/vm/isolate_listener.dart
+++ b/lib/src/runner/vm/isolate_listener.dart
@@ -117,26 +117,34 @@
       "type": "group",
       "name": group.name,
       "metadata": group.metadata.serialize(),
+      "setUpAll": _serializeTest(group.setUpAll),
+      "tearDownAll": _serializeTest(group.tearDownAll),
       "entries": group.entries.map((entry) {
-        if (entry is Group) return _serializeGroup(entry);
-
-        var test = entry as Test;
-        var receivePort = new ReceivePort();
-        receivePort.listen((message) {
-          assert(message['command'] == 'run');
-          _runTest(test, message['reply']);
-        });
-
-        return {
-          "type": "test",
-          "name": test.name,
-          "metadata": test.metadata.serialize(),
-          "sendPort": receivePort.sendPort
-        };
+        return entry is Group ? _serializeGroup(entry) : _serializeTest(entry);
       }).toList()
     };
   }
 
+  /// Serializes [test] into a JSON-safe map.
+  ///
+  /// Returns `null` if [test] is `null`.
+  Map _serializeTest(Test test) {
+    if (test == null) return null;
+
+    var receivePort = new ReceivePort();
+    receivePort.listen((message) {
+      assert(message['command'] == 'run');
+      _runTest(test, message['reply']);
+    });
+
+    return {
+      "type": "test",
+      "name": test.name,
+      "metadata": test.metadata.serialize(),
+      "sendPort": receivePort.sendPort
+    };
+  }
+
   /// Runs [test] and sends the results across [sendPort].
   void _runTest(Test test, SendPort sendPort) {
     var liveTest = test.load(_suite);
diff --git a/lib/test.dart b/lib/test.dart
index e662d1e..48235ff 100644
--- a/lib/test.dart
+++ b/lib/test.dart
@@ -187,6 +187,34 @@
 /// reverse of the order they were declared.
 void tearDown(callback()) => _declarer.tearDown(callback);
 
+/// Registers a function to be run once before all tests.
+///
+/// [callback] may be asynchronous; if so, it must return a [Future].
+///
+/// If this is called within a test group, [callback] will run before all tests
+/// in that group. It will be run after any [setUpAll] callbacks in parent
+/// groups or at the top level. It won't be run if none of the tests in the
+/// group are run.
+///
+/// **Note**: This function makes it very easy to accidentally introduce hidden
+/// dependencies between tests that should be isolated. In general, you should
+/// prefer [setUp], and only use [setUpAll] if the callback is prohibitively
+/// slow.
+void setUpAll(callback()) => _declarer.setUpAll(callback);
+
+/// Registers a function to be run once after all tests.
+///
+/// If this is called within a test group, [callback] will run after all tests
+/// in that group. It will be run before any [tearDownAll] callbacks in parent
+/// groups or at the top level. It won't be run if none of the tests in the
+/// group are run.
+///
+/// **Note**: This function makes it very easy to accidentally introduce hidden
+/// dependencies between tests that should be isolated. In general, you should
+/// prefer [tearDown], and only use [tearDOwnAll] if the callback is
+/// prohibitively slow.
+void tearDownAll(callback()) => _declarer.tearDownAll(callback);
+
 /// Registers an exception that was caught for the current test.
 void registerException(error, [StackTrace stackTrace]) {
   // This will usually forward directly to [Invoker.current.handleError], but
diff --git a/pubspec.yaml b/pubspec.yaml
index 89683f2..61854b5 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,5 +1,5 @@
 name: test
-version: 0.12.4+9
+version: 0.12.5
 author: Dart Team <misc@dartlang.org>
 description: A library for writing dart unit tests.
 homepage: https://github.com/dart-lang/test
@@ -16,7 +16,7 @@
   http_multi_server: '^1.0.0'
   http_parser: '>=0.0.2 <2.0.0'
   path: '^1.2.0'
-  pool: '^1.1.0'
+  pool: '^1.2.0'
   pub_semver: '^1.0.0'
   shelf: '>=0.6.0 <0.7.0'
   shelf_static: '^0.2.0'
diff --git a/test/frontend/set_up_all_test.dart b/test/frontend/set_up_all_test.dart
new file mode 100644
index 0000000..7cfc274
--- /dev/null
+++ b/test/frontend/set_up_all_test.dart
@@ -0,0 +1,324 @@
+// Copyright (c) 2015, 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 'dart:async';
+
+import 'package:async/async.dart';
+import 'package:test/test.dart';
+
+import '../utils.dart';
+
+void main() {
+  test("runs once before all tests", () {
+    return expectTestsPass(() {
+      var setUpAllRun = false;
+      setUpAll(() {
+        expect(setUpAllRun, isFalse);
+        setUpAllRun = true;
+      });
+
+      test("test 1", () {
+        expect(setUpAllRun, isTrue);
+      });
+
+      test("test 2", () {
+        expect(setUpAllRun, isTrue);
+      });
+    });
+  });
+
+  test("runs once per group, outside-in", () {
+    return expectTestsPass(() {
+      var setUpAll1Run = false;
+      var setUpAll2Run = false;
+      var setUpAll3Run = false;
+      setUpAll(() {
+        expect(setUpAll1Run, isFalse);
+        expect(setUpAll2Run, isFalse);
+        expect(setUpAll3Run, isFalse);
+        setUpAll1Run = true;
+      });
+
+      group("mid", () {
+        setUpAll(() {
+          expect(setUpAll1Run, isTrue);
+          expect(setUpAll2Run, isFalse);
+          expect(setUpAll3Run, isFalse);
+          setUpAll2Run = true;
+        });
+
+        group("inner", () {
+          setUpAll(() {
+            expect(setUpAll1Run, isTrue);
+            expect(setUpAll2Run, isTrue);
+            expect(setUpAll3Run, isFalse);
+            setUpAll3Run = true;
+          });
+
+          test("test", () {
+            expect(setUpAll1Run, isTrue);
+            expect(setUpAll2Run, isTrue);
+            expect(setUpAll3Run, isTrue);
+          });
+        });
+      });
+    });
+  });
+
+  test("runs before setUps", () {
+    return expectTestsPass(() {
+      var setUpAllRun = false;
+      setUp(() {
+        expect(setUpAllRun, isTrue);
+      });
+
+      setUpAll(() {
+        expect(setUpAllRun, isFalse);
+        setUpAllRun = true;
+      });
+
+      setUp(() {
+        expect(setUpAllRun, isTrue);
+      });
+
+      test("test", () {
+        expect(setUpAllRun, isTrue);
+      });
+    });
+  });
+
+  test("multiples run in order", () {
+    return expectTestsPass(() {
+      var setUpAll1Run = false;
+      var setUpAll2Run = false;
+      var setUpAll3Run = false;
+      setUpAll(() {
+        expect(setUpAll1Run, isFalse);
+        expect(setUpAll2Run, isFalse);
+        expect(setUpAll3Run, isFalse);
+        setUpAll1Run = true;
+      });
+
+      setUpAll(() {
+        expect(setUpAll1Run, isTrue);
+        expect(setUpAll2Run, isFalse);
+        expect(setUpAll3Run, isFalse);
+        setUpAll2Run = true;
+      });
+
+      setUpAll(() {
+        expect(setUpAll1Run, isTrue);
+        expect(setUpAll2Run, isTrue);
+        expect(setUpAll3Run, isFalse);
+        setUpAll3Run = true;
+      });
+
+      test("test", () {
+        expect(setUpAll1Run, isTrue);
+        expect(setUpAll2Run, isTrue);
+        expect(setUpAll3Run, isTrue);
+      });
+    });
+  });
+
+  group("asynchronously", () {
+    test("blocks additional setUpAlls on in-band async", () {
+      return expectTestsPass(() {
+        var setUpAll1Run = false;
+        var setUpAll2Run = false;
+        var setUpAll3Run = false;
+        setUpAll(() async {
+          expect(setUpAll1Run, isFalse);
+          expect(setUpAll2Run, isFalse);
+          expect(setUpAll3Run, isFalse);
+          await pumpEventQueue();
+          setUpAll1Run = true;
+        });
+
+        setUpAll(() async {
+          expect(setUpAll1Run, isTrue);
+          expect(setUpAll2Run, isFalse);
+          expect(setUpAll3Run, isFalse);
+          await pumpEventQueue();
+          setUpAll2Run = true;
+        });
+
+        setUpAll(() async {
+          expect(setUpAll1Run, isTrue);
+          expect(setUpAll2Run, isTrue);
+          expect(setUpAll3Run, isFalse);
+          await pumpEventQueue();
+          setUpAll3Run = true;
+        });
+
+        test("test", () {
+          expect(setUpAll1Run, isTrue);
+          expect(setUpAll2Run, isTrue);
+          expect(setUpAll3Run, isTrue);
+        });
+      });
+    });
+
+    test("doesn't block additional setUpAlls on out-of-band async", () {
+      return expectTestsPass(() {
+        var setUpAll1Run = false;
+        var setUpAll2Run = false;
+        var setUpAll3Run = false;
+        setUpAll(() {
+          expect(setUpAll1Run, isFalse);
+          expect(setUpAll2Run, isFalse);
+          expect(setUpAll3Run, isFalse);
+
+          expect(pumpEventQueue().then((_) {
+            setUpAll1Run = true;
+          }), completes);
+        });
+
+        setUpAll(() {
+          expect(setUpAll1Run, isFalse);
+          expect(setUpAll2Run, isFalse);
+          expect(setUpAll3Run, isFalse);
+
+          expect(pumpEventQueue().then((_) {
+            setUpAll2Run = true;
+          }), completes);
+        });
+
+        setUpAll(() {
+          expect(setUpAll1Run, isFalse);
+          expect(setUpAll2Run, isFalse);
+          expect(setUpAll3Run, isFalse);
+
+          expect(pumpEventQueue().then((_) {
+            setUpAll3Run = true;
+          }), completes);
+        });
+
+        test("test", () {
+          expect(setUpAll1Run, isTrue);
+          expect(setUpAll2Run, isTrue);
+          expect(setUpAll3Run, isTrue);
+        });
+      });
+    });
+  });
+
+  test("isn't run for a skipped group", () async {
+    // Declare this in the outer test so if it runs, the outer test will fail.
+    var shouldNotRun = expectAsync(() {}, count: 0);
+
+    var engine = declareEngine(() {
+      group("skipped", () {
+        setUpAll(shouldNotRun);
+
+        test("test", () {});
+      }, skip: true);
+    });
+
+    await engine.run();
+    expect(engine.liveTests, hasLength(1));
+    expect(engine.skipped, hasLength(1));
+    expect(engine.liveTests, equals(engine.skipped));
+  });
+
+  test("is emitted through Engine.onTestStarted", () async {
+    var engine = declareEngine(() {
+      setUpAll(() {});
+
+      test("test", () {});
+    });
+
+    var queue = new StreamQueue(engine.onTestStarted);
+    var setUpAllFuture = queue.next;
+    var liveTestFuture = queue.next;
+
+    await engine.run();
+
+    var setUpAllLiveTest = await setUpAllFuture;
+    expect(setUpAllLiveTest.test.name, equals("(setUpAll)"));
+    expectTestPassed(setUpAllLiveTest);
+
+    // The fake test for setUpAll should be removed from the engine's live
+    // test list so that reporters don't display it as a passed test.
+    expect(engine.liveTests, isNot(contains(setUpAllLiveTest)));
+    expect(engine.passed, isNot(contains(setUpAllLiveTest)));
+    expect(engine.failed, isNot(contains(setUpAllLiveTest)));
+    expect(engine.skipped, isNot(contains(setUpAllLiveTest)));
+    expect(engine.active, isNot(contains(setUpAllLiveTest)));
+
+    var liveTest = await liveTestFuture;
+    expectTestPassed(await liveTestFuture);
+    expect(engine.liveTests, contains(liveTest));
+    expect(engine.passed, contains(liveTest));
+  });
+
+  group("with an error", () {
+    test("reports the error and remains in Engine.liveTests", () async {
+      var engine = declareEngine(() {
+        setUpAll(() => throw new TestFailure("fail"));
+
+        test("test", () {});
+      });
+
+      var queue = new StreamQueue(engine.onTestStarted);
+      var setUpAllFuture = queue.next;
+
+      expect(await engine.run(), isFalse);
+
+      var setUpAllLiveTest = await setUpAllFuture;
+      expect(setUpAllLiveTest.test.name, equals("(setUpAll)"));
+      expectTestFailed(setUpAllLiveTest, "fail");
+
+      // The fake test for setUpAll should be removed from the engine's live
+      // test list so that reporters don't display it as a passed test.
+      expect(engine.liveTests, contains(setUpAllLiveTest));
+      expect(engine.failed, contains(setUpAllLiveTest));
+      expect(engine.passed, isNot(contains(setUpAllLiveTest)));
+      expect(engine.skipped, isNot(contains(setUpAllLiveTest)));
+      expect(engine.active, isNot(contains(setUpAllLiveTest)));
+    });
+
+    test("doesn't run tests in the group", () async {
+      // Declare this in the outer test so if it runs, the outer test will fail.
+      var shouldNotRun = expectAsync(() {}, count: 0);
+
+      var engine = declareEngine(() {
+        setUpAll(() => throw "error");
+
+        test("test", shouldNotRun);
+      });
+
+      expect(await engine.run(), isFalse);
+    });
+
+    test("doesn't run inner groups", () async {
+      // Declare this in the outer test so if it runs, the outer test will fail.
+      var shouldNotRun = expectAsync(() {}, count: 0);
+
+      var engine = declareEngine(() {
+        setUpAll(() => throw "error");
+
+        group("group", () {
+          test("test", shouldNotRun);
+        });
+      });
+
+      expect(await engine.run(), isFalse);
+    });
+
+    test("doesn't run further setUpAlls", () async {
+      // Declare this in the outer test so if it runs, the outer test will fail.
+      var shouldNotRun = expectAsync(() {}, count: 0);
+
+      var engine = declareEngine(() {
+        setUpAll(() => throw "error");
+        setUpAll(shouldNotRun);
+
+        test("test", shouldNotRun);
+      });
+
+      expect(await engine.run(), isFalse);
+    });
+  });
+}
diff --git a/test/frontend/tear_down_all_test.dart b/test/frontend/tear_down_all_test.dart
new file mode 100644
index 0000000..a5d9e0b
--- /dev/null
+++ b/test/frontend/tear_down_all_test.dart
@@ -0,0 +1,372 @@
+// Copyright (c) 2015, 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 'dart:async';
+
+import 'package:async/async.dart';
+import 'package:test/test.dart';
+
+import '../utils.dart';
+
+void main() {
+  test("runs once after all tests", () {
+    return expectTestsPass(() {
+      var test1Run = false;
+      var test2Run = false;
+      var tearDownAllRun = false;
+      tearDownAll(() {
+        expect(test1Run, isTrue);
+        expect(test2Run, isTrue);
+        expect(tearDownAllRun, isFalse);
+        tearDownAllRun = true;
+      });
+
+      test("test 1", () {
+        expect(tearDownAllRun, isFalse);
+        test1Run = true;
+      });
+
+      test("test 2", () {
+        expect(tearDownAllRun, isFalse);
+        test2Run = true;
+      });
+    });
+  });
+
+  test("runs once per group, inside-out", () {
+    return expectTestsPass(() {
+      var tearDownAll1Run = false;
+      var tearDownAll2Run = false;
+      var tearDownAll3Run = false;
+      var testRun = false;
+      tearDownAll(() {
+        expect(tearDownAll1Run, isFalse);
+        expect(tearDownAll2Run, isTrue);
+        expect(tearDownAll3Run, isTrue);
+        expect(testRun, isTrue);
+        tearDownAll1Run = true;
+      });
+
+      group("mid", () {
+        tearDownAll(() {
+          expect(tearDownAll1Run, isFalse);
+          expect(tearDownAll2Run, isFalse);
+          expect(tearDownAll3Run, isTrue);
+          expect(testRun, isTrue);
+          tearDownAll2Run = true;
+        });
+
+        group("inner", () {
+          tearDownAll(() {
+            expect(tearDownAll1Run, isFalse);
+            expect(tearDownAll2Run, isFalse);
+            expect(tearDownAll3Run, isFalse);
+            expect(testRun, isTrue);
+            tearDownAll3Run = true;
+          });
+
+          test("test", () {
+            expect(tearDownAll1Run, isFalse);
+            expect(tearDownAll2Run, isFalse);
+            expect(tearDownAll3Run, isFalse);
+            testRun = true;
+          });
+        });
+      });
+    });
+  });
+
+  test("runs after tearDowns", () {
+    return expectTestsPass(() {
+      var tearDown1Run = false;
+      var tearDown2Run = false;
+      var tearDownAllRun = false;
+      tearDown(() {
+        expect(tearDownAllRun, isFalse);
+        tearDown1Run = true;
+      });
+
+      tearDownAll(() {
+        expect(tearDown1Run, isTrue);
+        expect(tearDown2Run, isTrue);
+        expect(tearDownAllRun, isFalse);
+        tearDownAllRun = true;
+      });
+
+      tearDown(() {
+        expect(tearDownAllRun, isFalse);
+        tearDown2Run = true;
+      });
+
+      test("test", () {
+        expect(tearDownAllRun, isFalse);
+      });
+    });
+  });
+
+  test("multiples run in reverse order", () {
+    return expectTestsPass(() {
+      var tearDownAll1Run = false;
+      var tearDownAll2Run = false;
+      var tearDownAll3Run = false;
+      tearDownAll(() {
+        expect(tearDownAll1Run, isFalse);
+        expect(tearDownAll2Run, isTrue);
+        expect(tearDownAll3Run, isTrue);
+        tearDownAll1Run = true;
+      });
+
+      tearDownAll(() {
+        expect(tearDownAll1Run, isFalse);
+        expect(tearDownAll2Run, isFalse);
+        expect(tearDownAll3Run, isTrue);
+        tearDownAll2Run = true;
+      });
+
+      tearDownAll(() {
+        expect(tearDownAll1Run, isFalse);
+        expect(tearDownAll2Run, isFalse);
+        expect(tearDownAll3Run, isFalse);
+        tearDownAll3Run = true;
+      });
+
+      test("test", () {
+        expect(tearDownAll1Run, isFalse);
+        expect(tearDownAll2Run, isFalse);
+        expect(tearDownAll3Run, isFalse);
+      });
+    });
+  });
+
+  group("asynchronously", () {
+    test("blocks additional tearDownAlls on in-band async", () {
+      return expectTestsPass(() {
+        var tearDownAll1Run = false;
+        var tearDownAll2Run = false;
+        var tearDownAll3Run = false;
+        tearDownAll(() async {
+          expect(tearDownAll1Run, isFalse);
+          expect(tearDownAll2Run, isTrue);
+          expect(tearDownAll3Run, isTrue);
+          await pumpEventQueue();
+          tearDownAll1Run = true;
+        });
+
+        tearDownAll(() async {
+          expect(tearDownAll1Run, isFalse);
+          expect(tearDownAll2Run, isFalse);
+          expect(tearDownAll3Run, isTrue);
+          await pumpEventQueue();
+          tearDownAll2Run = true;
+        });
+
+        tearDownAll(() async {
+          expect(tearDownAll1Run, isFalse);
+          expect(tearDownAll2Run, isFalse);
+          expect(tearDownAll3Run, isFalse);
+          await pumpEventQueue();
+          tearDownAll3Run = true;
+        });
+
+        test("test", () {
+          expect(tearDownAll1Run, isFalse);
+          expect(tearDownAll2Run, isFalse);
+          expect(tearDownAll3Run, isFalse);
+        });
+      });
+    });
+
+    test("doesn't block additional tearDownAlls on out-of-band async", () {
+      return expectTestsPass(() {
+        var tearDownAll1Run = false;
+        var tearDownAll2Run = false;
+        var tearDownAll3Run = false;
+        tearDownAll(() {
+          expect(tearDownAll1Run, isFalse);
+          expect(tearDownAll2Run, isFalse);
+          expect(tearDownAll3Run, isFalse);
+
+          expect(new Future(() {
+            tearDownAll1Run = true;
+          }), completes);
+        });
+
+        tearDownAll(() {
+          expect(tearDownAll1Run, isFalse);
+          expect(tearDownAll2Run, isFalse);
+          expect(tearDownAll3Run, isFalse);
+
+          expect(new Future(() {
+            tearDownAll2Run = true;
+          }), completes);
+        });
+
+        tearDownAll(() {
+          expect(tearDownAll1Run, isFalse);
+          expect(tearDownAll2Run, isFalse);
+          expect(tearDownAll3Run, isFalse);
+
+          expect(new Future(() {
+            tearDownAll3Run = true;
+          }), completes);
+        });
+
+        test("test", () {
+          expect(tearDownAll1Run, isFalse);
+          expect(tearDownAll2Run, isFalse);
+          expect(tearDownAll3Run, isFalse);
+        });
+      });
+    });
+
+    test("blocks further tests on in-band async", () {
+      return expectTestsPass(() {
+        var tearDownAllRun = false;
+        group("group", () {
+          tearDownAll(() async {
+            expect(tearDownAllRun, isFalse);
+            await pumpEventQueue();
+            tearDownAllRun = true;
+          });
+
+          test("test", () {});
+        });
+
+        test("after", () {
+          expect(tearDownAllRun, isTrue);
+        });
+      });
+    });
+
+    test("blocks further tests on out-of-band async", () {
+      return expectTestsPass(() {
+        var tearDownAllRun = false;
+        group("group", () {
+          tearDownAll(() async {
+            expect(tearDownAllRun, isFalse);
+            expect(pumpEventQueue().then((_) {
+              tearDownAllRun = true;
+            }), completes);
+          });
+
+          test("test", () {});
+        });
+
+        test("after", () {
+          expect(tearDownAllRun, isTrue);
+        });
+      });
+    });
+  });
+
+  test("isn't run for a skipped group", () async {
+    // Declare this in the outer test so if it runs, the outer test will fail.
+    var shouldNotRun = expectAsync(() {}, count: 0);
+
+    var engine = declareEngine(() {
+      group("skipped", () {
+        tearDownAll(shouldNotRun);
+
+        test("test", () {});
+      }, skip: true);
+    });
+
+    await engine.run();
+    expect(engine.liveTests, hasLength(1));
+    expect(engine.skipped, hasLength(1));
+    expect(engine.liveTests, equals(engine.skipped));
+  });
+
+  test("is emitted through Engine.onTestStarted", () async {
+    var engine = declareEngine(() {
+      tearDownAll(() {});
+
+      test("test", () {});
+    });
+
+    var queue = new StreamQueue(engine.onTestStarted);
+    var liveTestFuture = queue.next;
+    var tearDownAllFuture = queue.next;
+
+    await engine.run();
+
+    var tearDownAllLiveTest = await tearDownAllFuture;
+    expect(tearDownAllLiveTest.test.name, equals("(tearDownAll)"));
+    expectTestPassed(tearDownAllLiveTest);
+
+    // The fake test for tearDownAll should be removed from the engine's live
+    // test list so that reporters don't display it as a passed test.
+    expect(engine.liveTests, isNot(contains(tearDownAllLiveTest)));
+    expect(engine.passed, isNot(contains(tearDownAllLiveTest)));
+    expect(engine.failed, isNot(contains(tearDownAllLiveTest)));
+    expect(engine.skipped, isNot(contains(tearDownAllLiveTest)));
+    expect(engine.active, isNot(contains(tearDownAllLiveTest)));
+
+    var liveTest = await liveTestFuture;
+    expectTestPassed(await liveTestFuture);
+    expect(engine.liveTests, contains(liveTest));
+    expect(engine.passed, contains(liveTest));
+  });
+
+  group("with an error", () {
+    test("reports the error and remains in Engine.liveTests", () async {
+      var engine = declareEngine(() {
+        tearDownAll(() => throw new TestFailure("fail"));
+
+        test("test", () {});
+      });
+
+      var queue = new StreamQueue(engine.onTestStarted);
+      expect(queue.next, completes);
+      var tearDownAllFuture = queue.next;
+
+      expect(await engine.run(), isFalse);
+
+      var tearDownAllLiveTest = await tearDownAllFuture;
+      expect(tearDownAllLiveTest.test.name, equals("(tearDownAll)"));
+      expectTestFailed(tearDownAllLiveTest, "fail");
+
+      // The fake test for tearDownAll should be removed from the engine's live
+      // test list so that reporters don't display it as a passed test.
+      expect(engine.liveTests, contains(tearDownAllLiveTest));
+      expect(engine.failed, contains(tearDownAllLiveTest));
+      expect(engine.passed, isNot(contains(tearDownAllLiveTest)));
+      expect(engine.skipped, isNot(contains(tearDownAllLiveTest)));
+      expect(engine.active, isNot(contains(tearDownAllLiveTest)));
+    });
+
+    test("runs further tearDownAlls", () async {
+      // Declare this in the outer test so if it doesn't runs, the outer test
+      // will fail.
+      var shouldRun = expectAsync(() {});
+
+      var engine = declareEngine(() {
+        tearDownAll(() => throw "error");
+        tearDownAll(shouldRun);
+
+        test("test", () {});
+      });
+
+      expect(await engine.run(), isFalse);
+    });
+
+    test("runs outer tearDownAlls", () async {
+      // Declare this in the outer test so if it doesn't runs, the outer test
+      // will fail.
+      var shouldRun = expectAsync(() {});
+
+      var engine = declareEngine(() {
+        tearDownAll(shouldRun);
+
+        group("group", () {
+          tearDownAll(() => throw "error");
+
+          test("test", () {});
+        });
+      });
+
+      expect(await engine.run(), isFalse);
+    });
+  });
+}
diff --git a/test/runner/browser/runner_test.dart b/test/runner/browser/runner_test.dart
index 14ad58d..dcd18c6 100644
--- a/test/runner/browser/runner_test.dart
+++ b/test/runner/browser/runner_test.dart
@@ -211,6 +211,40 @@
       test.shouldExit(0);
     });
 
+    test("with setUpAll", () {
+      d.file("test.dart", r"""
+          import 'package:test/test.dart';
+
+          void main() {
+            setUpAll(() => print("in setUpAll"));
+
+            test("test", () {});
+          }
+          """).create();
+
+      var test = runTest(["-p", "content-shell", "test.dart"]);
+      test.stdout.expect(consumeThrough(contains('+0: (setUpAll)')));
+      test.stdout.expect('in setUpAll');
+      test.shouldExit(0);
+    });
+
+    test("with tearDownAll", () {
+      d.file("test.dart", r"""
+          import 'package:test/test.dart';
+
+          void main() {
+            tearDownAll(() => print("in tearDownAll"));
+
+            test("test", () {});
+          }
+          """).create();
+
+      var test = runTest(["-p", "content-shell", "test.dart"]);
+      test.stdout.expect(consumeThrough(contains('+1: (tearDownAll)')));
+      test.stdout.expect('in tearDownAll');
+      test.shouldExit(0);
+    });
+
     // Regression test; this broke in 0.12.0-beta.9.
     test("on a file in a subdirectory", () {
       d.dir("dir", [d.file("test.dart", _success)]).create();
diff --git a/test/runner/engine_test.dart b/test/runner/engine_test.dart
index bb6a7db..37d1213 100644
--- a/test/runner/engine_test.dart
+++ b/test/runner/engine_test.dart
@@ -57,11 +57,11 @@
   test("emits each test before it starts running and after the previous test "
       "finished", () {
     var testsRun = 0;
-    var engine = withTests(declare(() {
+    var engine = declareEngine(() {
       for (var i = 0; i < 3; i++) {
         test("test ${i + 1}", expectAsync(() => testsRun++, max: 1));
       }
-    }));
+    });
 
     engine.onTestStarted.listen(expectAsync((liveTest) {
       // [testsRun] should be one less than the test currently running.
@@ -77,33 +77,33 @@
   });
 
   test(".run() returns true if every test passes", () {
-    var engine = withTests(declare(() {
+    var engine = declareEngine(() {
       for (var i = 0; i < 2; i++) {
         test("test ${i + 1}", () {});
       }
-    }));
+    });
 
     expect(engine.run(), completion(isTrue));
   });
 
   test(".run() returns false if any test fails", () {
-    var engine = withTests(declare(() {
+    var engine = declareEngine(() {
       for (var i = 0; i < 2; i++) {
         test("test ${i + 1}", () {});
       }
       test("failure", () => throw new TestFailure("oh no"));
-    }));
+    });
 
     expect(engine.run(), completion(isFalse));
   });
 
   test(".run() returns false if any test errors", () {
-    var engine = withTests(declare(() {
+    var engine = declareEngine(() {
       for (var i = 0; i < 2; i++) {
         test("test ${i + 1}", () {});
       }
       test("failure", () => throw "oh no");
-    }));
+    });
 
     expect(engine.run(), completion(isFalse));
   });
@@ -117,9 +117,9 @@
   group("for a skipped test", () {
     test("doesn't run the test's body", () async {
       var bodyRun = false;
-      var engine = withTests(declare(() {
+      var engine = declareEngine(() {
         test("test", () => bodyRun = true, skip: true);
-      }));
+      });
 
       await engine.run();
       expect(bodyRun, isFalse);
@@ -130,7 +130,9 @@
         test("test", () {}, skip: true);
       });
 
-      var engine = withTests(tests);
+      var engine = new Engine.withSuites([
+        new RunnerSuite(const VMEnvironment(), new Group.root(tests))
+      ]);
 
       engine.onTestStarted.listen(expectAsync((liveTest) {
         expect(liveTest, same(engine.liveTests.single));
@@ -151,10 +153,3 @@
     });
   });
 }
-
-/// Returns an engine that will run [tests].
-Engine withTests(List<Test> tests) {
-  return new Engine.withSuites([
-    new RunnerSuite(const VMEnvironment(), new Group.root(tests))
-  ]);
-}
diff --git a/test/runner/set_up_all_test.dart b/test/runner/set_up_all_test.dart
new file mode 100644
index 0000000..2301eb4
--- /dev/null
+++ b/test/runner/set_up_all_test.dart
@@ -0,0 +1,120 @@
+// Copyright (c) 2015, 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.
+
+@TestOn("vm")
+
+import 'package:scheduled_test/descriptor.dart' as d;
+import 'package:scheduled_test/scheduled_stream.dart';
+import 'package:scheduled_test/scheduled_test.dart';
+
+import '../io.dart';
+
+void main() {
+  useSandbox();
+
+  test("an error causes the run to fail", () {
+    d.file("test.dart", r"""
+        import 'package:test/test.dart';
+
+        void main() {
+          setUpAll(() => throw "oh no");
+
+          test("test", () {});
+        }
+        """).create();
+
+    var test = runTest(["test.dart"]);
+    test.stdout.expect(consumeThrough(contains("-1: (setUpAll)")));
+    test.stdout.expect(consumeThrough(contains("-1: Some tests failed.")));
+    test.shouldExit(1);
+  });
+
+  test("doesn't run if no tests in the group are selected", () {
+    d.file("test.dart", r"""
+        import 'package:test/test.dart';
+
+        void main() {
+          group("with setUpAll", () {
+            setUpAll(() => throw "oh no");
+
+            test("test", () {});
+          });
+
+          group("without setUpAll", () {
+            test("test", () {});
+          });
+        }
+        """).create();
+
+    var test = runTest(["test.dart", "--name", "without"]);
+    test.stdout.expect(never(contains("(setUpAll)")));
+    test.shouldExit(0);
+  });
+
+  test("doesn't run if no tests in the group are selected", () {
+    d.file("test.dart", r"""
+        import 'package:test/test.dart';
+
+        void main() {
+          group("group", () {
+            setUpAll(() => throw "oh no");
+
+            test("with", () {});
+          });
+
+          group("group", () {
+            test("without", () {});
+          });
+        }
+        """).create();
+
+    var test = runTest(["test.dart", "--name", "without"]);
+    test.stdout.expect(never(contains("(setUpAll)")));
+    test.shouldExit(0);
+  });
+
+  test("doesn't run if no tests in the group match the platform", () {
+    d.file("test.dart", r"""
+        import 'package:test/test.dart';
+
+        void main() {
+          group("group", () {
+            setUpAll(() => throw "oh no");
+
+            test("with", () {}, testOn: "browser");
+          });
+
+          group("group", () {
+            test("without", () {});
+          });
+        }
+        """).create();
+
+    var test = runTest(["test.dart"]);
+    test.stdout.expect(never(contains("(setUpAll)")));
+    test.shouldExit(0);
+  });
+
+  test("doesn't run if the group doesn't match the platform", () {
+    d.file("test.dart", r"""
+        import 'package:test/test.dart';
+
+        void main() {
+          group("group", () {
+            setUpAll(() => throw "oh no");
+
+            test("with", () {});
+          }, testOn: "browser");
+
+          group("group", () {
+            test("without", () {});
+          });
+        }
+        """).create();
+
+    var test = runTest(["test.dart"]);
+    test.stdout.expect(never(contains("(setUpAll)")));
+    test.shouldExit(0);
+  });
+}
diff --git a/test/runner/signal_test.dart b/test/runner/signal_test.dart
index 5397d07..63e8e7b 100644
--- a/test/runner/signal_test.dart
+++ b/test/runner/signal_test.dart
@@ -82,7 +82,11 @@
 import 'package:test/test.dart';
 
 void main() {
-  tearDown(() => new File("output").writeAsStringSync("ran teardown"));
+  tearDownAll(() {
+    new File("output_all").writeAsStringSync("ran tearDownAll");
+  });
+
+  tearDown(() => new File("output").writeAsStringSync("ran tearDown"));
 
   test("test", () {
     print("running test");
@@ -95,7 +99,34 @@
       test.stdout.expect(consumeThrough("running test"));
       signalAndQuit(test);
 
-      d.file("output", "ran teardown").validate();
+      d.file("output", "ran tearDown").validate();
+      d.file("output_all", "ran tearDownAll").validate();
+      expectTempDirEmpty();
+    });
+
+    test("waits for an active tearDownAll to finish running", () {
+      d.file("test.dart", """
+import 'dart:async';
+import 'dart:io';
+
+import 'package:test/test.dart';
+
+void main() {
+  tearDownAll(() async {
+    print("running tearDownAll");
+    await new Future.delayed(new Duration(seconds: 1));
+    new File("output").writeAsStringSync("ran tearDownAll");
+  });
+
+  test("test", () {});
+}
+""").create();
+
+      var test = _runTest(["test.dart"]);
+      test.stdout.expect(consumeThrough("running tearDownAll"));
+      signalAndQuit(test);
+
+      d.file("output", "ran tearDownAll").validate();
       expectTempDirEmpty();
     });
 
diff --git a/test/runner/tear_down_all_test.dart b/test/runner/tear_down_all_test.dart
new file mode 100644
index 0000000..9b192c3
--- /dev/null
+++ b/test/runner/tear_down_all_test.dart
@@ -0,0 +1,120 @@
+// Copyright (c) 2015, 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.
+
+@TestOn("vm")
+
+import 'package:scheduled_test/descriptor.dart' as d;
+import 'package:scheduled_test/scheduled_stream.dart';
+import 'package:scheduled_test/scheduled_test.dart';
+
+import '../io.dart';
+
+void main() {
+  useSandbox();
+
+  test("an error causes the run to fail", () {
+    d.file("test.dart", r"""
+        import 'package:test/test.dart';
+
+        void main() {
+          tearDownAll(() => throw "oh no");
+
+          test("test", () {});
+        }
+        """).create();
+
+    var test = runTest(["test.dart"]);
+    test.stdout.expect(consumeThrough(contains("-1: (tearDownAll)")));
+    test.stdout.expect(consumeThrough(contains("-1: Some tests failed.")));
+    test.shouldExit(1);
+  });
+
+  test("doesn't run if no tests in the group are selected", () {
+    d.file("test.dart", r"""
+        import 'package:test/test.dart';
+
+        void main() {
+          group("with tearDownAll", () {
+            tearDownAll(() => throw "oh no");
+
+            test("test", () {});
+          });
+
+          group("without tearDownAll", () {
+            test("test", () {});
+          });
+        }
+        """).create();
+
+    var test = runTest(["test.dart", "--name", "without"]);
+    test.stdout.expect(never(contains("(tearDownAll)")));
+    test.shouldExit(0);
+  });
+
+  test("doesn't run if no tests in the group are selected", () {
+    d.file("test.dart", r"""
+        import 'package:test/test.dart';
+
+        void main() {
+          group("group", () {
+            tearDownAll(() => throw "oh no");
+
+            test("with", () {});
+          });
+
+          group("group", () {
+            test("without", () {});
+          });
+        }
+        """).create();
+
+    var test = runTest(["test.dart", "--name", "without"]);
+    test.stdout.expect(never(contains("(tearDownAll)")));
+    test.shouldExit(0);
+  });
+
+  test("doesn't run if no tests in the group match the platform", () {
+    d.file("test.dart", r"""
+        import 'package:test/test.dart';
+
+        void main() {
+          group("group", () {
+            tearDownAll(() => throw "oh no");
+
+            test("with", () {}, testOn: "browser");
+          });
+
+          group("group", () {
+            test("without", () {});
+          });
+        }
+        """).create();
+
+    var test = runTest(["test.dart"]);
+    test.stdout.expect(never(contains("(tearDownAll)")));
+    test.shouldExit(0);
+  });
+
+  test("doesn't run if the group doesn't match the platform", () {
+    d.file("test.dart", r"""
+        import 'package:test/test.dart';
+
+        void main() {
+          group("group", () {
+            tearDownAll(() => throw "oh no");
+
+            test("with", () {});
+          }, testOn: "browser");
+
+          group("group", () {
+            test("without", () {});
+          });
+        }
+        """).create();
+
+    var test = runTest(["test.dart"]);
+    test.stdout.expect(never(contains("(tearDownAll)")));
+    test.shouldExit(0);
+  });
+}
diff --git a/test/utils.dart b/test/utils.dart
index acbec12..9662716 100644
--- a/test/utils.dart
+++ b/test/utils.dart
@@ -16,7 +16,10 @@
 import 'package:test/src/backend/state.dart';
 import 'package:test/src/backend/suite.dart';
 import 'package:test/src/runner/application_exception.dart';
+import 'package:test/src/runner/engine.dart';
 import 'package:test/src/runner/load_exception.dart';
+import 'package:test/src/runner/runner_suite.dart';
+import 'package:test/src/runner/vm/environment.dart';
 import 'package:test/src/util/remote_exception.dart';
 import 'package:test/test.dart';
 
@@ -284,8 +287,29 @@
   return future;
 }
 
+/// Runs [body] with a declarer, runs all the declared tests, and asserts that
+/// they pass.
+Future expectTestsPass(void body()) async {
+  var engine = declareEngine(body);
+  var success = await engine.run();
+
+  for (var test in engine.liveTests) {
+    expectTestPassed(test);
+  }
+
+  expect(success, isTrue);
+}
+
 /// Runs [body] with a declarer and returns the declared entries.
 List<GroupEntry> declare(void body()) {
   var declarer = new Declarer()..declare(body);
   return declarer.build().entries;
 }
+
+/// Runs [body] with a declarer and returns an engine that runs those tests.
+Engine declareEngine(void body()) {
+  var declarer = new Declarer()..declare(body);
+  return new Engine.withSuites([
+    new RunnerSuite(const VMEnvironment(), declarer.build())
+  ]);
+}