diff --git a/CHANGELOG.md b/CHANGELOG.md
index a5ab1c6..a272c2f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,7 +3,7 @@ an <a href="/marcglasberg/SameAppDifferentTech/blob/main/Mobil
 Async Redux App Example Repository</a> in GitHub for a full-fledged example with a complete app
 showcasing the fundamentals and best practices described in the AsyncRedux README.md file._
 
-# 22.4.1
+# 22.4.2
 
 * For those who use `flutter_hooks`, you can now use the
   new https://pub.dev/packages/flutter_hooks_async_redux package
@@ -263,13 +263,13 @@ showcasing the fundamentals and best practices described in the AsyncRedux READM
   let action2 = BuyAction('TSLA');
   dispatch(action1);
   dispatch(action2);
-  await store.waitActions([action1, action2]);
+  await store.waitAllActions([action1, action2]);
   expect(store.state.portfolio.containsAll('IBM', 'TSLA'), isFalse);
   
   // Dispatches actions and wait until no actions are in progress.
   dispatch(BuyAction('IBM'));
   dispatch(SellAction('TSLA'));
-  await store.waitActions();
+  await store.waitAllActions();
   expect(the result of all actions...);
   
   // Dispatches two actions in SERIES and wait for them:
@@ -277,7 +277,7 @@ showcasing the fundamentals and best practices described in the AsyncRedux READM
   await dispatchAndWait(AnotherAsyncAction());
   expect(the result of both actions...);
   
-  // Wait until some action of any of the given types is dispatched.
+  // Wait until some action of the given types is dispatched.
   dispatch(ProcessStocksAction()); 
   var action = store.waitAnyActionTypeFinishes([BuyAction, SellAction]);  
   expect(store.state.portfolio.contains('IBM'), isTrue);  
diff --git a/README.md b/README.md
index dfb276b..57ce6fa 100644
--- a/README.md
+++ b/README.md
@@ -1613,13 +1613,13 @@ let action1 = BuyAction('IBM');
 let action2 = BuyAction('TSLA');
 dispatch(action1);
 dispatch(action2);
-await store.waitActions([action1, action2]);
+await store.waitAllActions([action1, action2]);
 expect(store.state.portfolio.containsAll('IBM', 'TSLA'), isFalse);
 
 // Dispatches actions and wait until no actions are in progress.
 dispatch(BuyAction('IBM'));
 dispatch(SellAction('TSLA'));
-await store.waitActions();
+await store.waitAllActions();
 expect(the result of all actions...);
 
 // Dispatches two actions in SERIES and wait for them:
@@ -1627,7 +1627,7 @@ await dispatchAndWait(SomeAsyncAction());
 await dispatchAndWait(AnotherAsyncAction());
 expect(the result of both actions...);
 
-// Wait until some action of any of the given types is dispatched.
+// Wait until some action of the given types is dispatched.
 dispatch(ProcessStocksAction()); 
 var action = store.waitAnyActionTypeFinishes([BuyAction, SellAction]);  
 expect(store.state.portfolio.contains('IBM'), isTrue);  
diff --git a/lib/src/store.dart b/lib/src/store.dart
index b2e8061..71c99ba 100644
--- a/lib/src/store.dart
+++ b/lib/src/store.dart
@@ -475,7 +475,7 @@ class Store<St> {
   /// // Dispatches actions in PARALLEL and wait until no actions are in progress.
   /// dispatch(BuyAction('IBM'));
   /// dispatch(BuyAction('TSLA'));
-  /// await store.waitActions();
+  /// await store.waitAllActions();
   /// expect(store.state.portfolio.containsAll('IBM', 'TSLA'), isFalse);
   ///
   /// // Dispatches two actions in PARALLEL and wait for them:
@@ -483,7 +483,7 @@ class Store<St> {
   /// let action2 = SellAction('TSLA');
   /// dispatch(action1);
   /// dispatch(action2);
-  /// await store.waitActions([action1, action2]);
+  /// await store.waitAllActions([action1, action2]);
   /// expect(store.state.portfolio.contains('IBM'), isTrue);
   /// expect(store.state.portfolio.contains('TSLA'), isFalse);
   ///
@@ -499,7 +499,7 @@ class Store<St> {
   /// expect(action.status.isCompleteOk, isTrue);
   /// expect(store.state.name, 'Bill');
   ///
-  /// // Wait until some action of any of the given types is dispatched.
+  /// // Wait until some action of the given types is dispatched.
   /// dispatch(ProcessStocksAction());
   /// var action = store.waitAnyActionTypeFinishes([BuyAction, SellAction]);
   /// expect(store.state.portfolio.contains('IBM'), isTrue);
@@ -563,8 +563,8 @@ class Store<St> {
   /// var action = await store.waitActionCondition((actionsInProgress, triggerAction) { ... }
   /// ```
   ///
-  /// You get back the set of the actions being dispatched that met the condition, as well as
-  /// the action that triggered the condition by being added or removed from the set.
+  /// You get back an unmodifiable set of the actions being dispatched that met the condition,
+  /// as well as the action that triggered the condition by being added or removed from the set.
   ///
   /// Note: The condition is only checked when some action is dispatched or finishes dispatching.
   /// It's not checked every time action statuses change.
@@ -598,7 +598,7 @@ class Store<St> {
   /// // Dispatches actions in PARALLEL and wait until no actions are in progress.
   /// dispatch(BuyAction('IBM'));
   /// dispatch(BuyAction('TSLA'));
-  /// await store.waitActions();
+  /// await store.waitAllActions();
   /// expect(store.state.portfolio.containsAll('IBM', 'TSLA'), isFalse);
   ///
   /// // Dispatches two actions in PARALLEL and wait for them:
@@ -606,7 +606,7 @@ class Store<St> {
   /// let action2 = SellAction('TSLA');
   /// dispatch(action1);
   /// dispatch(action2);
-  /// await store.waitActions([action1, action2]);
+  /// await store.waitAllActions([action1, action2]);
   /// expect(store.state.portfolio.contains('IBM'), isTrue);
   /// expect(store.state.portfolio.contains('TSLA'), isFalse);
   ///
@@ -622,7 +622,7 @@ class Store<St> {
   /// expect(action.status.isCompleteOk, isTrue);
   /// expect(store.state.name, 'Bill');
   ///
-  /// // Wait until some action of any of the given types is dispatched.
+  /// // Wait until some action of the given types is dispatched.
   /// dispatch(ProcessStocksAction());
   /// var action = store.waitAnyActionTypeFinishes([BuyAction, SellAction]);
   /// expect(store.state.portfolio.contains('IBM'), isTrue);
@@ -639,13 +639,16 @@ class Store<St> {
   /// You should only use this method in tests.
   @visibleForTesting
   Future<(Set<ReduxAction<St>>, ReduxAction<St>?)> waitActionCondition(
-    bool Function(Set<ReduxAction<St>>, ReduxAction<St>?) condition, {
+    bool Function(Set<ReduxAction<St>> actions, ReduxAction<St>? triggerAction) condition, {
     int? timeoutMillis,
   }) {
     //
-    // If it's already true, return the actions in progress.
-    if (condition(_actionsInProgress, null))
-      return Future.value((_actionsInProgress.toSet(), null));
+    var unmodifiableActionsInProgress = UnmodifiableSetView(_actionsInProgress);
+
+    // If the condition is already true when `waitActionCondition` is called,
+    // complete and return the actions in progress.
+    if (condition(unmodifiableActionsInProgress, null))
+      return Future.value((unmodifiableActionsInProgress, null));
     //
     else {
       var completer = Completer<(Set<ReduxAction<St>>, ReduxAction<St>?)>();
@@ -694,7 +697,7 @@ class Store<St> {
   /// // Dispatches actions in PARALLEL and wait until no actions are in progress.
   /// dispatch(BuyAction('IBM'));
   /// dispatch(BuyAction('TSLA'));
-  /// await store.waitActions();
+  /// await store.waitAllActions();
   /// expect(store.state.portfolio.containsAll('IBM', 'TSLA'), isFalse);
   ///
   /// // Dispatches two actions in PARALLEL and wait for them:
@@ -702,7 +705,7 @@ class Store<St> {
   /// let action2 = SellAction('TSLA');
   /// dispatch(action1);
   /// dispatch(action2);
-  /// await store.waitActions([action1, action2]);
+  /// await store.waitAllActions([action1, action2]);
   /// expect(store.state.portfolio.contains('IBM'), isTrue);
   /// expect(store.state.portfolio.contains('TSLA'), isFalse);
   ///
@@ -718,7 +721,7 @@ class Store<St> {
   /// expect(action.status.isCompleteOk, isTrue);
   /// expect(store.state.name, 'Bill');
   ///
-  /// // Wait until some action of any of the given types is dispatched.
+  /// // Wait until some action of the given types is dispatched.
   /// dispatch(ProcessStocksAction());
   /// var action = store.waitAnyActionTypeFinishes([BuyAction, SellAction]);
   /// expect(store.state.portfolio.contains('IBM'), isTrue);
@@ -790,7 +793,7 @@ class Store<St> {
   /// // Dispatches actions in PARALLEL and wait until no actions are in progress.
   /// dispatch(BuyAction('IBM'));
   /// dispatch(BuyAction('TSLA'));
-  /// await store.waitActions();
+  /// await store.waitAllActions();
   /// expect(store.state.portfolio.containsAll('IBM', 'TSLA'), isFalse);
   ///
   /// // Dispatches two actions in PARALLEL and wait for them:
@@ -798,7 +801,7 @@ class Store<St> {
   /// let action2 = SellAction('TSLA');
   /// dispatch(action1);
   /// dispatch(action2);
-  /// await store.waitActions([action1, action2]);
+  /// await store.waitAllActions([action1, action2]);
   /// expect(store.state.portfolio.contains('IBM'), isTrue);
   /// expect(store.state.portfolio.contains('TSLA'), isFalse);
   ///
@@ -814,7 +817,7 @@ class Store<St> {
   /// expect(action.status.isCompleteOk, isTrue);
   /// expect(store.state.name, 'Bill');
   ///
-  /// // Wait until some action of any of the given types is dispatched.
+  /// // Wait until some action of the given types is dispatched.
   /// dispatch(ProcessStocksAction());
   /// var action = store.waitAnyActionTypeFinishes([BuyAction, SellAction]);
   /// expect(store.state.portfolio.contains('IBM'), isTrue);
@@ -837,8 +840,7 @@ class Store<St> {
     var (_, triggerAction) = await this.waitActionCondition(
       timeoutMillis: timeoutMillis,
       (actionsInProgress, triggerAction) {
-        if (actionsInProgress.any((action) => action.runtimeType == actionType)) return false;
-        return true;
+        return !actionsInProgress.any((action) => action.runtimeType == actionType);
       },
     );
 
@@ -848,11 +850,11 @@ class Store<St> {
   /// Returns a future that completes when ALL actions of the given type are NOT in progress
   /// (none of them is being dispatched):
   ///
-  /// - If no action of any of the given types is currently in progress when the method is called,
+  /// - If no action of the given types is currently in progress when the method is called,
   /// the future completes immediately.
   ///
-  /// - If an action of any of the given types is in progress, the future completes only when
-  /// no action of any of the given types is in progress anymore.
+  /// - If an action of the given types is in progress, the future completes only when
+  /// no action of the given types is in progress anymore.
   ///
   /// You may also provide a [timeoutMillis], which by default is 10 minutes.
   /// If you want, you can modify [StoreTester.defaultTimeoutMillis] to change the default timeout.
@@ -883,7 +885,7 @@ class Store<St> {
   /// // Dispatches actions in PARALLEL and wait until no actions are in progress.
   /// dispatch(BuyAction('IBM'));
   /// dispatch(BuyAction('TSLA'));
-  /// await store.waitActions();
+  /// await store.waitAllActions();
   /// expect(store.state.portfolio.containsAll('IBM', 'TSLA'), isFalse);
   ///
   /// // Dispatches two actions in PARALLEL and wait for them:
@@ -891,7 +893,7 @@ class Store<St> {
   /// let action2 = SellAction('TSLA');
   /// dispatch(action1);
   /// dispatch(action2);
-  /// await store.waitActions([action1, action2]);
+  /// await store.waitAllActions([action1, action2]);
   /// expect(store.state.portfolio.contains('IBM'), isTrue);
   /// expect(store.state.portfolio.contains('TSLA'), isFalse);
   ///
@@ -907,7 +909,7 @@ class Store<St> {
   /// expect(action.status.isCompleteOk, isTrue);
   /// expect(store.state.name, 'Bill');
   ///
-  /// // Wait until some action of any of the given types is dispatched.
+  /// // Wait until some action of the given types is dispatched.
   /// dispatch(ProcessStocksAction());
   /// var action = store.waitAnyActionTypeFinishes([BuyAction, SellAction]);
   /// expect(store.state.portfolio.contains('IBM'), isTrue);
@@ -945,10 +947,10 @@ class Store<St> {
     }
   }
 
-  /// Returns a future which will complete when an action of ANY of the given types FINISHES
-  /// dispatching. IMPORTANT: This method is different than the other similar methods, because
+  /// Returns a future which will complete when ANY action of the given types FINISHES
+  /// dispatching. IMPORTANT: This method is different from the other similar methods, because
   /// it does NOT complete immediately if no action of the given types is in progress. Instead,
-  /// it waits until an action of any of the given types finishes dispatching, even if they
+  /// it waits until an action of the given types finishes dispatching, even if they
   /// were not yet in progress when the method was called.
   ///
   /// This method returns the action that completed the future, which you can use to check
@@ -993,7 +995,7 @@ class Store<St> {
   /// // Dispatches actions in PARALLEL and wait until no actions are in progress.
   /// dispatch(BuyAction('IBM'));
   /// dispatch(BuyAction('TSLA'));
-  /// await store.waitActions();
+  /// await store.waitAllActions();
   /// expect(store.state.portfolio.containsAll('IBM', 'TSLA'), isFalse);
   ///
   /// // Dispatches two actions in PARALLEL and wait for them:
@@ -1001,7 +1003,7 @@ class Store<St> {
   /// let action2 = SellAction('TSLA');
   /// dispatch(action1);
   /// dispatch(action2);
-  /// await store.waitActions([action1, action2]);
+  /// await store.waitAllActions([action1, action2]);
   /// expect(store.state.portfolio.contains('IBM'), isTrue);
   /// expect(store.state.portfolio.contains('TSLA'), isFalse);
   ///
@@ -1017,7 +1019,7 @@ class Store<St> {
   /// expect(action.status.isCompleteOk, isTrue);
   /// expect(store.state.name, 'Bill');
   ///
-  /// // Wait until some action of any of the given types is dispatched.
+  /// // Wait until some action of the given types is dispatched.
   /// dispatch(ProcessStocksAction());
   /// var action = store.waitAnyActionTypeFinishes([BuyAction, SellAction]);
   /// expect(store.state.portfolio.contains('IBM'), isTrue);
@@ -1240,9 +1242,11 @@ class Store<St> {
   void _checkAllActionConditions(ReduxAction<St> triggerAction) {
     List<bool Function(Set<ReduxAction<St>>, ReduxAction<St>?)?> keysToRemove = [];
 
+    var unmodifiableActionsInProgress = UnmodifiableSetView(_actionsInProgress);
+
     _actionConditionCompleters.forEach((condition, completer) {
-      if (condition(_actionsInProgress, triggerAction)) {
-        completer.complete((_actionsInProgress.toSet(), triggerAction));
+      if (condition(unmodifiableActionsInProgress, triggerAction)) {
+        completer.complete((unmodifiableActionsInProgress, triggerAction));
         keysToRemove.add(condition);
       }
     });
diff --git a/lib/src/store_provider_and_connector.dart b/lib/src/store_provider_and_connector.dart
index 5e5dbbd..1a52cea 100644
--- a/lib/src/store_provider_and_connector.dart
+++ b/lib/src/store_provider_and_connector.dart
@@ -683,7 +683,7 @@ class StoreProvider<St> extends InheritedWidget {
     Key? key,
     required Store<St> store,
     required Widget child,
-  })  : _store = store,
+  })  : _store = _init(store),
         super(
           key: key,
           child: _InheritedUntypedDoesNotRebuild(store: store, child: child),
@@ -732,7 +732,8 @@ class StoreProvider<St> extends InheritedWidget {
     final _InheritedUntypedRebuilds? provider =
         context.dependOnInheritedWidgetOfExactType<_InheritedUntypedRebuilds>();
 
-    if (provider == null) throw _exceptionForWrongStoreType(_typeOf<StoreProvider>(), debug: debug);
+    if (provider == null)
+      throw _exceptionForWrongStoreType(_typeOf<_InheritedUntypedRebuilds>(), debug: debug);
 
     // We only turn on rebuilds when this `state` method is used for the first time.
     // This is to make it faster when this method is not used, which is the
@@ -855,82 +856,51 @@ class StoreProvider<St> extends InheritedWidget {
   static void clearExceptionFor(BuildContext context, Object actionOrTypeOrList) =>
       _getStoreWithDependency(context).clearExceptionFor(actionOrTypeOrList);
 
-  /// The [storeBackdoor] gives you direct access to the store for advanced use-cases, which means
-  /// you should avoid using it if you don't have a good reason to do so.
-  ///
-  /// It does NOT create a dependency like [_getStoreWithDependency] does, and it does NOT rebuild
-  /// the state when the state changes, when you access it like this:
-  /// `var state = StoreProvider.storeBackdoor(context, this).state;`
-  ///
-  /// Note: The recommended way to access the state in your app is to
-  /// use [StoreProvider.state], which can be accessed through the built-in
-  /// extension `context.getState<AppState>`, or define your own extension to simply
-  /// write `context.state`.
-  ///
-  /// The [storeBackdoor] can be used with `flutter_hooks`, for example, to create a custom hook:
-  ///
-  /// ```dart
-  /// /// The `converter` function should return the part of the state that the widget needs.
-  /// T useAppState<T>(T Function(AppState s) converter, { bool distinct = true }) {
-  ///   final store = StoreProvider.storeBackdoor<AppState>(useContext(), debug: 'useAppState hook');
-  ///   return use(_AppStateHook(store: store, converter: converter, distinct: distinct));
-  /// }
-  ///
-  /// Dispatch useDispatch() => useContext().dispatch;
-  /// DispatchSync useDispatchSync() => useContext().dispatchSync;
-  /// DispatchAndWait useDispatchAndWait() => useContext().dispatchAndWait;
-  /// bool Function(Object) useIsWaiting(Object actionOrTypeOrList) => useContext().isWaiting;
-  /// bool Function(Object) useIsFailed(Object actionOrTypeOrList) => useContext().isFailed;
-  /// UserException? Function(Object) exceptionFor(Object actionOrTypeOrList) => useContext().exceptionFor;
-  /// void Function(Object) clearExceptionFor(Object actionOrTypeOrList) => useContext().clearExceptionFor;
-  ///
-  /// class _AppStateHook<T, S extends AppState> extends Hook<T> {
-  ///   const _AppStateHook({required this.store,required this.converter,this.distinct = true});
-  ///   final T Function(S) converter;
-  ///   final bool distinct;
-  ///   final Store<S> store;
-  ///
-  ///   @override
-  ///   HookState<T, Hook<T>> createState() => _AppState_StateHook<T, S>();
-  /// }
-  ///
-  /// class _AppState_StateHook<T, S extends AppState> extends HookState<T, _AppStateHook<T, S>> {
-  ///   StreamSubscription? _storeSubscription;
-  ///   late T _state;
-  ///   bool get isInitialised => _storeSubscription != null;
-  ///
-  ///   @override
-  ///   void initHook() {
-  ///     super.initHook();
-  ///     _updateState(hook.store.state);
-  ///     final onStoreChanged = hook.store.onChange;
-  ///     _storeSubscription = onStoreChanged.listen(_updateState);
-  ///   }
-  ///
-  ///   @override
-  ///   T build(BuildContext context) => _state;
+  /// Avoid using if you don't have a good reason to do so.
   ///
-  ///   @override
-  ///   void dispose() {
-  ///     _storeSubscription?.cancel();
-  ///     super.dispose();
-  ///   }
+  /// The [backdoorStoreBackdoorInheritedWidget] gives you direct access to the store for advanced
+  /// use-cases. It does NOT create a dependency like [_getStoreWithDependency] does, and it does
+  /// NOT rebuild the state when the state changes, when you access it like this:
+  /// `var state = StoreProvider.backdoorInheritedWidget(context, this).state;`.
   ///
-  ///   void _updateState(S appState) {
-  ///     final state = hook.converter(appState);
-  ///     if (isInitialised && hook.distinct && state == _state) return;
-  ///     setState(() => _state = state);
-  ///   }
-  /// }
-  /// ```
-  ///
-  static Store<St> storeBackdoor<St>(BuildContext context, {Object? debug}) {
+  static Store<St> backdoorInheritedWidget<St>(BuildContext context, {Object? debug}) {
     final StoreProvider<St>? provider =
         context.dependOnInheritedWidgetOfExactType<StoreProvider<St>>();
+    if (provider == null)
+      throw _exceptionForWrongStoreType(_typeOf<StoreProvider<St>>(), debug: debug);
+    return provider._store;
+  }
 
-    if (provider == null) throw _exceptionForWrongStoreType(_typeOf<StoreProvider>(), debug: debug);
+  /// Avoid using if you don't have a good reason to do so.
+  ///
+  /// The [backdoorStaticGlobal] gives you direct access to the store for advanced use-cases.
+  /// It does NOT need the context, as it gets the store from the static
+  /// field [_staticStoreBackdoor]. Note this field is set when the [StoreProvider] is created,
+  /// which assumes the [StoreProvider] is used only once in your app. This is usually a
+  /// reasonable assumption, but can break in tests. It does NOT create a dependency
+  /// like [_getStoreWithDependency] does, and it does NOT rebuild the state when the state changes,
+  /// when you access it like this: `var state = StoreProvider.backdoorStaticGlobal<AppState>().state;`.
+  ///
+  static Store<St> backdoorStaticGlobal<St>() {
+    if (_staticStoreBackdoor == null)
+      throw StoreException('Error: No Redux store found. '
+          'Did you forget to use the StoreProvider?');
+
+    if (_staticStoreBackdoor is! Store<St>) {
+      var type = _typeOf<Store<St>>;
+      throw StoreException('Error: Store is of type ${_staticStoreBackdoor.runtimeType} '
+          'and not of type $type. Please provide the correct type.');
+    }
 
-    return provider._store;
+    return _staticStoreBackdoor as Store<St>;
+  }
+
+  /// See [backdoorStaticGlobal].
+  static Store? _staticStoreBackdoor;
+
+  static Store<St> _init<St>(Store<St> store) {
+    _staticStoreBackdoor = store;
+    return store;
   }
 
   @override
diff --git a/lib/src/store_tester.dart b/lib/src/store_tester.dart
index 332ff53..c091b86 100644
--- a/lib/src/store_tester.dart
+++ b/lib/src/store_tester.dart
@@ -373,7 +373,7 @@ class StoreTester<St> {
     return testInfo;
   }
 
-  /// Runs until an action of any of the given types is dispatched, and then waits until it
+  /// Runs until an action of the given types is dispatched, and then waits until it
   /// finishes. Returns the info after the action finishes. **Ignores other** actions types.
   ///
   Future<TestInfo<St>> waitUntilAny(
diff --git a/pubspec.yaml b/pubspec.yaml
index 74ea76b..3fc8ccc 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,6 +1,6 @@
 name: async_redux
 description: Redux state management. An optimized Redux version, which is very easy to learn and use, yet powerful and tailored for Flutter. It allows both sync and async reducers.
-version: 22.4.1
+version: 22.4.2
 # author: Marcelo Glasberg <marcglasberg@gmail.com>
 homepage: https://github.com/marcglasberg/async_redux
 topics:
diff --git a/test/store_provider_test.dart b/test/store_provider_test.dart
new file mode 100644
index 0000000..6f62905
--- /dev/null
+++ b/test/store_provider_test.dart
@@ -0,0 +1,22 @@
+import 'package:async_redux/async_redux.dart';
+import 'package:flutter/widgets.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  test('backdoorStaticGlobal', () async {
+    Store<String> store = Store<String>(initialState: "abc");
+    StoreProvider(store: store, child: Container());
+
+    expect(StoreProvider.backdoorStaticGlobal(), store);
+    expect(StoreProvider.backdoorStaticGlobal<dynamic>(), store);
+    expect(StoreProvider.backdoorStaticGlobal<String>(), store);
+
+    expect(() => StoreProvider.backdoorStaticGlobal<int>(), throwsA(isA<StoreException>()));
+
+    var backdoorStore = StoreProvider.backdoorStaticGlobal();
+    expect(backdoorStore, store);
+
+    var backdoorState = StoreProvider.backdoorStaticGlobal().state;
+    expect(backdoorState, "abc");
+  });
+}