add support for setUpClass and tearDownClass

if a test class defines `setUpClass` it will be run before any
tests are ever run. if it is asynchronous then no test runs
until the future is completed

`tearDownClass` is called once after all tests are run

tests are updated to support and check for new behavior

Author: RohitSaily

pkgs/test_reflective_loader/lib/test_reflective_loader.dart

@@ -87,8 +87,8 @@ void defineReflectiveTests(Type type) {
   {
     var isSolo = _hasAnnotationInstance(classMirror, soloTest);
     var className = MirrorSystem.getName(classMirror.simpleName);
-    group = _Group(isSolo, _combineNames(_currentSuiteName, className),
-        classMirror.testLocation);
+    group = _Group(
+        isSolo, _combineNames(_currentSuiteName, className), classMirror);
     _currentGroups.add(group);
   }
 
@@ -151,10 +151,24 @@ void _addTestsIfTopLevelSuite() {
   if (_currentSuiteLevel == 0) {
     void runTests({required bool allGroups, required bool allTests}) {
       for (var group in _currentGroups) {
+        var runTestCount = 0;
         if (allGroups || group.isSolo) {
           for (var test in group.tests) {
             if (allTests || test.isSolo) {
-              test_package.test(test.name, test.function,
+              if (!test.isSkipped) {
+                runTestCount += 1;
+              }
+              test_package.test(test.name, () async {
+                await group.ensureSetUpClass();
+                try {
+                  await test.function();
+                } finally {
+                  runTestCount -= 1;
+                  if (runTestCount == 0) {
+                    group.tearDownClass();
+                  }
+                }
+              },
                   timeout: test.timeout,
                   skip: test.isSkipped,
                   location: test.location);
@@ -210,14 +224,14 @@ bool _hasSkippedTestAnnotation(MethodMirror method) =>
     _hasAnnotationInstance(method, skippedTest);
 
 Future<Object?> _invokeSymbolIfExists(
-    InstanceMirror instanceMirror, Symbol symbol) {
+    ObjectMirror objectMirror, Symbol symbol) {
   Object? invocationResult;
   InstanceMirror? closure;
   try {
-    closure = instanceMirror.getField(symbol);
+    closure = objectMirror.getField(symbol);
     // ignore: avoid_catching_errors
   } on NoSuchMethodError {
-    // ignore
+    // ignore: empty_catches
   }
 
   if (closure is ClosureMirror) {
@@ -307,10 +321,13 @@ class _AssertFailingTest {
 class _Group {
   final bool isSolo;
   final String name;
-  final test_package.TestLocation? location;
   final List<_Test> tests = <_Test>[];
 
-  _Group(this.isSolo, this.name, this.location);
+  /// For static group-wide operations eg `setUpClass` and `tearDownClass`.
+  final ClassMirror _classMirror;
+  Future<Object?>? _setUpCompletion;
+
+  _Group(this.isSolo, this.name, this._classMirror);
 
   bool get hasSoloTest => tests.any((test) => test.isSolo);
 
@@ -327,6 +344,19 @@ class _Group {
     tests.add(_Test(isSolo, fullName, function, timeout?._timeout,
         memberMirror.testLocation));
   }
+
+  /// Runs group-wide setup if it has not been started yet,
+  /// ensuring it only runs once for a group. Set up runs and
+  /// completes before any test of the group runs
+  Future<Object?> ensureSetUpClass() =>
+      _setUpCompletion ??= _invokeSymbolIfExists(_classMirror, #setUpClass);
+
+  /// Runs group-wide tear down iff [ensureSetUpClass] was called at least once.
+  /// Must be called once and only called after all tests of the group have
+  /// completed
+  void tearDownClass() => _setUpCompletion != null
+      ? _invokeSymbolIfExists(_classMirror, #tearDownClass)
+      : null;
 }
 
 /// A marker annotation used to instruct dart2js to keep reflection information

pkgs/test_reflective_loader/test/location_test.dart

@@ -40,6 +40,11 @@ void main() {
         // the source code to ensure the locations match up.
         name = name.split('|').last.trim();
 
+        // Skip "tearDownAll" or "setUpAll", it never has a location.
+        if (name case '(tearDownAll)' || '(setUpAll)') {
+          continue;
+        }
+
         // Expect locations for all remaining fields.
         var url = test['url'] as String;
         var line = test['line'] as int;

pkgs/test_reflective_loader/test/test_reflective_loader_test.dart

@@ -11,23 +11,54 @@ import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 void main() {
   defineReflectiveSuite(() {
+    // ensure set-ups and tear-downs are not prematurely called ie before any
+    // tests actually execute
+    setUpAll(() {
+      expect(TestReflectiveLoaderTest.didSetUpClass, false);
+      expect(TestReflectiveLoaderTest.didTearDownClass, false);
+      expect(SecondTest.didSetUpClass, false);
+      expect(SecondTest.didTearDownClass, false);
+    });
     defineReflectiveTests(TestReflectiveLoaderTest);
+    defineReflectiveTests(SecondTest);
+    tearDownAll(() {
+      expect(TestReflectiveLoaderTest.didSetUpClass, true);
+      expect(TestReflectiveLoaderTest.didTearDownClass, true);
+      expect(SecondTest.didSetUpClass, true);
+      expect(SecondTest.didTearDownClass, true);
+    });
   });
 }
 
 @reflectiveTest
 class TestReflectiveLoaderTest {
-  void test_passes() {
-    expect(true, true);
+  static bool didSetUpClass = false;
+  static bool didTearDownClass = false;
+
+  static void setUpClass() {
+    expect(didSetUpClass, false);
+    didSetUpClass = true;
+    expect(didTearDownClass, false);
+  }
+
+  static void tearDownClass() {
+    expect(didSetUpClass, true);
+    expect(didTearDownClass, false);
+    didTearDownClass = true;
+  }
+
+  void test_classwide_state() {
+    expect(didSetUpClass, true);
+    expect(didTearDownClass, false);
   }
 
   @failingTest
   void test_fails() {
     expect(false, true);
   }
 
-  @failingTest
-  void test_fails_throws_sync() {
+  @skippedTest
+  void test_fails_but_skipped() {
     throw StateError('foo');
   }
 
@@ -36,13 +67,40 @@ class TestReflectiveLoaderTest {
     return Future.error('foo');
   }
 
-  @skippedTest
-  void test_fails_but_skipped() {
+  @failingTest
+  void test_fails_throws_sync() {
     throw StateError('foo');
   }
 
+  void test_passes() {
+    expect(true, true);
+  }
+
   @skippedTest
   void test_times_out_but_skipped() {
     while (true) {}
   }
 }
+
+@reflectiveTest
+class SecondTest {
+  static bool didSetUpClass = false;
+  static bool didTearDownClass = false;
+
+  static void setUpClass() {
+    expect(didSetUpClass, false);
+    didSetUpClass = true;
+    expect(didTearDownClass, false);
+  }
+
+  static void tearDownClass() {
+    expect(didSetUpClass, true);
+    expect(didTearDownClass, false);
+    didTearDownClass = true;
+  }
+
+  void test_classwide_state() {
+    expect(didSetUpClass, true);
+    expect(didTearDownClass, false);
+  }
+}