setUp/tearDown may be called repeatedly in a group.

test/backend/declarer_test.dart

 // 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:test/src/backend/declarer.dart';
 import 'package:test/src/backend/invoker.dart';
 import 'package:test/src/backend/suite.dart';
 import 'package:test/src/frontend/timeout.dart';
@@ skipping 61 matching lines @@
         return new Future(() => setUpRun = true);
       });
 
       _declarer.test("description", expectAsync(() {
         expect(setUpRun, isTrue);
       }, max: 1));
 
       return _runTest(0);
     });
 
-    test("can't be called multiple times", () {
-      _declarer.setUp(() {});
-      expect(() => _declarer.setUp(() {}), throwsStateError);
+    test("runs in call order within a group", () async {
+      var firstSetUpRun = false;
+      var secondSetUpRun = false;
+      var thirdSetUpRun = false;
+      _declarer.setUp(expectAsync(() async {
+        expect(secondSetUpRun, isFalse);
+        expect(thirdSetUpRun, isFalse);
+        firstSetUpRun = true;
+      }));
+
+      _declarer.setUp(expectAsync(() async {
+        expect(firstSetUpRun, isTrue);
+        expect(thirdSetUpRun, isFalse);
+        secondSetUpRun = true;
+      }));
+
+      _declarer.setUp(expectAsync(() async {
+        expect(firstSetUpRun, isTrue);
+        expect(secondSetUpRun, isTrue);
+        thirdSetUpRun = true;
+      }));
+
+      _declarer.test("description", expectAsync(() {
+        expect(firstSetUpRun, isTrue);
+        expect(secondSetUpRun, isTrue);
+        expect(thirdSetUpRun, isTrue);
+      }));
+
+      await _runTest(0);
     });
   });
 
   group(".tearDown()", () {
     test("is run after all tests", () async {
       var tearDownRun;
       _declarer.setUp(() => tearDownRun = false);
       _declarer.tearDown(() => tearDownRun = true);
 
       _declarer.test("description 1", expectAsync(() {
@@ skipping 66 matching lines @@
           Invoker.current.removeOutstandingCallback();
         });
       });
 
       _declarer.test("description", () {});
 
       await _runTest(0);
       expect(outstandingCallbackRemoved, isTrue);
     });
 
-    test("can't be called multiple times", () {
-      _declarer.tearDown(() {});
-      expect(() => _declarer.tearDown(() {}), throwsStateError);
+    test("runs in reverse call order within a group", () async {
+      var firstTearDownRun = false;
+      var secondTearDownRun = false;
+      var thirdTearDownRun = false;
+      _declarer.tearDown(expectAsync(() async {
+        expect(secondTearDownRun, isTrue);
+        expect(thirdTearDownRun, isTrue);
+        firstTearDownRun = true;
+      }));
+
+      _declarer.tearDown(expectAsync(() async {
+        expect(firstTearDownRun, isFalse);
+        expect(thirdTearDownRun, isTrue);
+        secondTearDownRun = true;
+      }));
+
+      _declarer.tearDown(expectAsync(() async {
+        expect(firstTearDownRun, isFalse);
+        expect(secondTearDownRun, isFalse);
+        thirdTearDownRun = true;
+      }));
+
+      _declarer.test("description", expectAsync(() {
+        expect(firstTearDownRun, isFalse);
+        expect(secondTearDownRun, isFalse);
+        expect(thirdTearDownRun, isFalse);
+      }, max: 1));
+
+      await _runTest(0);
+    });
+
+    test("runs further tearDowns in a group even if one fails", () async {
+      _declarer.tearDown(expectAsync(() {}));
+
+      _declarer.tearDown(() async {
+        throw 'error';
+      });
+
+      _declarer.test("description", expectAsync(() {}));
+
+      await _runTest(0, shouldFail: true);
     });
   });
 
   group("in a group,", () {
     test("tests inherit the group's description", () {
       _declarer.group("group", () {
         _declarer.test("description", () {});
       });
 
       expect(_declarer.tests, hasLength(1));
@@ skipping 103 matching lines @@
           }, max: 1));
 
           _declarer.test("description", expectAsync(() {
             expect(outerSetUpRun, isTrue);
             expect(innerSetUpRun, isTrue);
           }, max: 1));
         });
 
         return _runTest(0);
       });
-
-      test("can't be called multiple times", () {
-        _declarer.group("group", () {
-          _declarer.setUp(() {});
-          expect(() => _declarer.setUp(() {}), throwsStateError);
-        });
-      });
     });
 
     group(".tearDown()", () {
       test("is scoped to the group", () async {
         var tearDownRun;
         _declarer.setUp(() => tearDownRun = false);
 
         _declarer.group("group", () {
           _declarer.tearDown(() => tearDownRun = true);
 
@@ skipping 87 matching lines @@
           });
 
           _declarer.test("description", expectAsync(() {
             expect(outerTearDownRun, isFalse);
           }, max: 1));
         });
 
         await _runTest(0, shouldFail: true);
         expect(outerTearDownRun, isTrue);
       });
-
-      test("can't be called multiple times", () {
-        _declarer.group("group", () {
-          _declarer.tearDown(() {});
-          expect(() => _declarer.tearDown(() {}), throwsStateError);
-        });
-      });
     });
   });
 }
 
 /// Runs the test at [index] defined on [_declarer].
 ///
 /// This automatically sets up an `onError` listener to ensure that the test
 /// doesn't throw any invisible exceptions.
 Future _runTest(int index, {bool shouldFail: false}) {
   var liveTest = _declarer.tests[index].load(_suite);
 
   liveTest.onError.listen(shouldFail
       ? expectAsync((_) {})
-      : expectAsync((_) {},
-            count: 0, reason: "No errors expected for test #$index."));
+      : (error) => registerException(error.error, error.stackTrace));
 
   return liveTest.run();
 }