Add support for setUpAll and tearDownAll.

test/frontend/tear_down_all_test.dart

Index: test/frontend/tear_down_all_test.dart
diff --git a/test/frontend/tear_down_all_test.dart b/test/frontend/tear_down_all_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..a5d9e0b1f30fb963d715139a2f5c446c8f55f4c5
--- /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);
+    });
+  });
+}