fix(bloc_test): test timeouts due to uncaught exceptions (#3854)

Author: felangel

packages/bloc_test/lib/src/bloc_test.dart

@@ -196,8 +196,8 @@ Future<void> testBloc<B extends BlocBase<State>, State>({
   );
   Bloc.observer = testObserver;
 
-  await runZonedGuarded(
-    () async {
+  try {
+    await _runZonedGuarded(() async {
       await setUp?.call();
       final states = <State>[];
       final bloc = build();
@@ -229,26 +229,36 @@ Future<void> testBloc<B extends BlocBase<State>, State>({
       await subscription.cancel();
       await verify?.call(bloc);
       await tearDown?.call();
-    },
-    (Object error, _) {
-      if (shallowEquality && error is test.TestFailure) {
-        // ignore: only_throw_errors
-        throw test.TestFailure(
-          '''
+    });
+  } catch (error) {
+    if (shallowEquality && error is test.TestFailure) {
+      // ignore: only_throw_errors
+      throw test.TestFailure(
+        '''
 ${error.message}
 WARNING: Please ensure state instances extend Equatable, override == and hashCode, or implement Comparable.
 Alternatively, consider using Matchers in the expect of the blocTest rather than concrete state instances.\n''',
-        );
-      }
-      if (errors == null || !unhandledErrors.contains(error)) {
-        // ignore: only_throw_errors
-        throw error;
-      }
-    },
-  );
+      );
+    }
+    if (errors == null || !unhandledErrors.contains(error)) {
+      rethrow;
+    }
+  }
+
   if (errors != null) test.expect(unhandledErrors, test.wrapMatcher(errors()));
 }
 
+Future<void> _runZonedGuarded(Future<void> Function() body) {
+  final completer = Completer<void>();
+  runZonedGuarded(() async {
+    await body();
+    if (!completer.isCompleted) completer.complete();
+  }, (error, stackTrace) {
+    if (!completer.isCompleted) completer.completeError(error, stackTrace);
+  });
+  return completer.future;
+}
+
 class _TestBlocObserver extends BlocObserver {
   const _TestBlocObserver(this._localObserver, this._onError);
 

packages/bloc_test/test/bloc_bloc_test_test.dart

@@ -169,6 +169,17 @@ void main() {
         });
         expect(actualError, exception);
       });
+
+      test('future still completes when uncaught exception occurs', () async {
+        await expectLater(
+          () => testBloc<ErrorCounterBloc, int>(
+            build: () => ErrorCounterBloc(),
+            act: (bloc) => bloc.add(CounterEvent.increment),
+            expect: () => const <int>[1],
+          ),
+          throwsA(isA<ErrorCounterBlocError>()),
+        );
+      });
     });
 
     group('AsyncCounterBloc', () {
@@ -638,7 +649,7 @@ Alternatively, consider using Matchers in the expect of the blocTest rather than
           await completer.future;
         }, (Object error, _) {
           actualError = error;
-          completer.complete();
+          if (!completer.isCompleted) completer.complete();
         });
         expect((actualError as TestFailure).message, expectedError);
       });