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

the same `InstanceMirror` is used for the setup and for the
tear-down, following how setup and tear-down is done for each
unit test

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);
   }
 
@@ -154,12 +154,16 @@ void _addTestsIfTopLevelSuite() {
         if (allGroups || group.isSolo) {
           for (var test in group.tests) {
             if (allTests || test.isSolo) {
-              test_package.test(test.name, test.function,
+              test_package.test(test.name, () async {
+                await group.ensureSetUpClass();
+                test.function();
+              },
                   timeout: test.timeout,
                   skip: test.isSkipped,
                   location: test.location);
             }
           }
+          test_package.tearDownAll(() => group.tearDownClass());
         }
       }
     }
@@ -217,7 +221,7 @@ Future<Object?> _invokeSymbolIfExists(
     closure = instanceMirror.getField(symbol);
     // ignore: avoid_catching_errors
   } on NoSuchMethodError {
-    // ignore
+    // ignore: empty_catches
   }
 
   if (closure is ClosureMirror) {
@@ -307,10 +311,14 @@ 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);
+  /// Shared across group-wide operations eg `setUpClass` and `tearDownClass`.
+  final InstanceMirror _instance;
+  Future<Object?>? _setUpCompletion;
+
+  _Group(this.isSolo, this.name, ClassMirror classMirror)
+      : _instance = classMirror.newInstance(const Symbol(''), []);
 
   bool get hasSoloTest => tests.any((test) => test.isSolo);
 
@@ -327,6 +335,16 @@ 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(_instance, #setUpClass);
+
+  /// Runs group-wide tear down after all tests of the group have
+  /// run
+  void tearDownClass() => _invokeSymbolIfExists(_instance, #tearDownClass);
 }
 
 /// 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", it never has a location.
+        if (name == '(tearDownAll)') {
+          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

@@ -15,19 +15,31 @@ void main() {
   });
 }
 
+var _didSetUpClass = false;
+var _didTearDownClass = false;
+
 @reflectiveTest
 class TestReflectiveLoaderTest {
-  void test_passes() {
-    expect(true, true);
+  void setUpClass() {
+    _didSetUpClass = true;
+  }
+
+  void tearDownClass() {
+    _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,11 +48,15 @@ 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) {}