test: refactored tests for multipliers

packages/pinball_components/test/helpers/mocks.dart

@@ -24,3 +24,5 @@ class MockGoogleLetterCubit extends Mock implements GoogleLetterCubit {}
 class MockSparkyBumperCubit extends Mock implements SparkyBumperCubit {}
 
 class MockDashNestBumperCubit extends Mock implements DashNestBumperCubit {}
+
+class MockMultiplierCubit extends Mock implements MultiplierCubit {}

packages/pinball_components/test/src/components/multiplier/cubit/multiplier_cubit_test.dart

@@ -0,0 +1,62 @@
+// ignore_for_file: prefer_const_constructors
+
+import 'package:bloc_test/bloc_test.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:pinball_components/pinball_components.dart';
+
+void main() {
+  group(
+    'MultiplierCubit',
+    () {
+      blocTest<MultiplierCubit, MultiplierState>(
+        'emits [lit] when toggle dimmed with same multiplier value',
+        build: () => MultiplierCubit(MultiplierValue.x2),
+        act: (bloc) => bloc.toggle(2),
+        expect: () => [
+          isA<MultiplierState>()
+            ..having(
+              (state) => state.spriteState,
+              'spriteState',
+              MultiplierSpriteState.lit,
+            ),
+        ],
+      );
+
+      blocTest<MultiplierCubit, MultiplierState>(
+        'emits [dimmed] when toggle lit with different multiplier value',
+        build: () => MultiplierCubit(MultiplierValue.x2),
+        seed: () => MultiplierState(
+          value: MultiplierValue.x2,
+          spriteState: MultiplierSpriteState.lit,
+        ),
+        act: (bloc) => bloc.toggle(3),
+        expect: () => [
+          isA<MultiplierState>()
+            ..having(
+              (state) => state.spriteState,
+              'spriteState',
+              MultiplierSpriteState.dimmed,
+            ),
+        ],
+      );
+
+      blocTest<MultiplierCubit, MultiplierState>(
+        'emits nothing when toggle lit with same multiplier value',
+        build: () => MultiplierCubit(MultiplierValue.x2),
+        seed: () => MultiplierState(
+          value: MultiplierValue.x2,
+          spriteState: MultiplierSpriteState.lit,
+        ),
+        act: (bloc) => bloc.toggle(2),
+        expect: () => <MultiplierState>[],
+      );
+
+      blocTest<MultiplierCubit, MultiplierState>(
+        'emits nothing when toggle dimmed with different multiplier value',
+        build: () => MultiplierCubit(MultiplierValue.x2),
+        act: (bloc) => bloc.toggle(3),
+        expect: () => <MultiplierState>[],
+      );
+    },
+  );
+}

packages/pinball_components/test/src/components/multiplier/cubit/multiplier_state_test.dart

@@ -0,0 +1,75 @@
+// ignore_for_file: prefer_const_constructors
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:pinball_components/src/pinball_components.dart';
+
+void main() {
+  group('MultiplierState', () {
+    test('supports value equality', () {
+      expect(
+        MultiplierState(
+          value: MultiplierValue.x2,
+          spriteState: MultiplierSpriteState.lit,
+        ),
+        equals(
+          MultiplierState(
+            value: MultiplierValue.x2,
+            spriteState: MultiplierSpriteState.lit,
+          ),
+        ),
+      );
+    });
+
+    group('constructor', () {
+      test('can be instantiated', () {
+        expect(
+          MultiplierState(
+            value: MultiplierValue.x2,
+            spriteState: MultiplierSpriteState.lit,
+          ),
+          isNotNull,
+        );
+      });
+    });
+
+    group('copyWith', () {
+      test(
+        'copies correctly '
+        'when no argument specified',
+        () {
+          const multiplierState = MultiplierState(
+            value: MultiplierValue.x2,
+            spriteState: MultiplierSpriteState.lit,
+          );
+          expect(
+            multiplierState.copyWith(),
+            equals(multiplierState),
+          );
+        },
+      );
+
+      test(
+        'copies correctly '
+        'when all arguments specified',
+        () {
+          const multiplierState = MultiplierState(
+            value: MultiplierValue.x2,
+            spriteState: MultiplierSpriteState.lit,
+          );
+          final otherMultiplierState = MultiplierState(
+            value: MultiplierValue.x2,
+            spriteState: MultiplierSpriteState.dimmed,
+          );
+          expect(multiplierState, isNot(equals(otherMultiplierState)));
+
+          expect(
+            multiplierState.copyWith(
+              spriteState: MultiplierSpriteState.dimmed,
+            ),
+            equals(otherMultiplierState),
+          );
+        },
+      );
+    });
+  });
+}

packages/pinball_components/test/src/components/multiplier/multiplier_test.dart

@@ -0,0 +1,472 @@
+// ignore_for_file: cascade_invocations, prefer_const_constructors
+
+import 'package:bloc_test/bloc_test.dart';
+import 'package:flame/components.dart';
+import 'package:flame_test/flame_test.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mocktail/mocktail.dart';
+import 'package:pinball_components/pinball_components.dart';
+
+import '../../../helpers/helpers.dart';
+
+void main() {
+  final bloc = MockMultiplierCubit();
+
+  group('MultiplierSpriteGroupComponent', () {
+    TestWidgetsFlutterBinding.ensureInitialized();
+    final assets = [
+      Assets.images.multiplier.x2.lit.keyName,
+      Assets.images.multiplier.x2.dimmed.keyName,
+      Assets.images.multiplier.x3.lit.keyName,
+      Assets.images.multiplier.x3.dimmed.keyName,
+      Assets.images.multiplier.x4.lit.keyName,
+      Assets.images.multiplier.x4.dimmed.keyName,
+      Assets.images.multiplier.x5.lit.keyName,
+      Assets.images.multiplier.x5.dimmed.keyName,
+      Assets.images.multiplier.x6.lit.keyName,
+      Assets.images.multiplier.x6.dimmed.keyName,
+    ];
+    final flameTester = FlameTester(() => TestGame(assets));
+
+    group('renders correctly', () {
+      group('x2', () {
+        const multiplierValue = MultiplierValue.x2;
+
+        flameTester.testGameWidget(
+          'lit when bloc state is lit',
+          setUp: (game, tester) async {
+            await game.images.loadAll(assets);
+
+            whenListen(
+              bloc,
+              const Stream<MultiplierState>.empty(),
+              initialState: MultiplierState(
+                value: multiplierValue,
+                spriteState: MultiplierSpriteState.lit,
+              ),
+            );
+
+            final multiplier = Multiplier.test(
+              value: multiplierValue,
+              bloc: bloc,
+            );
+            await game.ensureAdd(multiplier);
+            await tester.pump();
+
+            game.camera.followVector2(Vector2.zero());
+          },
+          verify: (game, tester) async {
+            expect(
+              game
+                  .descendants()
+                  .whereType<MultiplierSpriteGroupComponent>()
+                  .first
+                  .current,
+              MultiplierSpriteState.lit,
+            );
+
+            await expectLater(
+              find.byGame<TestGame>(),
+              matchesGoldenFile('golden/multipliers/x2-lit.png'),
+            );
+          },
+        );
+
+        flameTester.testGameWidget(
+          'dimmed when bloc state is dimmed',
+          setUp: (game, tester) async {
+            await game.images.loadAll(assets);
+
+            whenListen(
+              bloc,
+              const Stream<MultiplierState>.empty(),
+              initialState: MultiplierState(
+                value: multiplierValue,
+                spriteState: MultiplierSpriteState.dimmed,
+              ),
+            );
+
+            final multiplier = Multiplier.test(
+              value: multiplierValue,
+              bloc: bloc,
+            );
+            await game.ensureAdd(multiplier);
+            await tester.pump();
+
+            game.camera.followVector2(Vector2.zero());
+          },
+          verify: (game, tester) async {
+            expect(
+              game
+                  .descendants()
+                  .whereType<MultiplierSpriteGroupComponent>()
+                  .first
+                  .current,
+              MultiplierSpriteState.dimmed,
+            );
+
+            await expectLater(
+              find.byGame<TestGame>(),
+              matchesGoldenFile('golden/multipliers/x2-dimmed.png'),
+            );
+          },
+        );
+      });
+
+      group('x3', () {
+        const multiplierValue = MultiplierValue.x3;
+
+        flameTester.testGameWidget(
+          'lit when bloc state is lit',
+          setUp: (game, tester) async {
+            await game.images.loadAll(assets);
+
+            whenListen(
+              bloc,
+              const Stream<MultiplierState>.empty(),
+              initialState: MultiplierState(
+                value: multiplierValue,
+                spriteState: MultiplierSpriteState.lit,
+              ),
+            );
+
+            final multiplier = Multiplier.test(
+              value: multiplierValue,
+              bloc: bloc,
+            );
+            await game.ensureAdd(multiplier);
+            await tester.pump();
+
+            game.camera.followVector2(Vector2.zero());
+          },
+          verify: (game, tester) async {
+            expect(
+              game
+                  .descendants()
+                  .whereType<MultiplierSpriteGroupComponent>()
+                  .first
+                  .current,
+              MultiplierSpriteState.lit,
+            );
+
+            await expectLater(
+              find.byGame<TestGame>(),
+              matchesGoldenFile('golden/multipliers/x3-lit.png'),
+            );
+          },
+        );
+
+        flameTester.testGameWidget(
+          'dimmed when bloc state is dimmed',
+          setUp: (game, tester) async {
+            await game.images.loadAll(assets);
+
+            whenListen(
+              bloc,
+              const Stream<MultiplierState>.empty(),
+              initialState: MultiplierState(
+                value: multiplierValue,
+                spriteState: MultiplierSpriteState.dimmed,
+              ),
+            );
+
+            final multiplier = Multiplier.test(
+              value: multiplierValue,
+              bloc: bloc,
+            );
+            await game.ensureAdd(multiplier);
+            await tester.pump();
+
+            game.camera.followVector2(Vector2.zero());
+          },
+          verify: (game, tester) async {
+            expect(
+              game
+                  .descendants()
+                  .whereType<MultiplierSpriteGroupComponent>()
+                  .first
+                  .current,
+              MultiplierSpriteState.dimmed,
+            );
+
+            await expectLater(
+              find.byGame<TestGame>(),
+              matchesGoldenFile('golden/multipliers/x3-dimmed.png'),
+            );
+          },
+        );
+      });
+
+      group('x4', () {
+        const multiplierValue = MultiplierValue.x4;
+
+        flameTester.testGameWidget(
+          'lit when bloc state is lit',
+          setUp: (game, tester) async {
+            await game.images.loadAll(assets);
+
+            whenListen(
+              bloc,
+              const Stream<MultiplierState>.empty(),
+              initialState: MultiplierState(
+                value: multiplierValue,
+                spriteState: MultiplierSpriteState.lit,
+              ),
+            );
+
+            final multiplier = Multiplier.test(
+              value: multiplierValue,
+              bloc: bloc,
+            );
+            await game.ensureAdd(multiplier);
+            await tester.pump();
+
+            game.camera.followVector2(Vector2.zero());
+          },
+          verify: (game, tester) async {
+            expect(
+              game
+                  .descendants()
+                  .whereType<MultiplierSpriteGroupComponent>()
+                  .first
+                  .current,
+              MultiplierSpriteState.lit,
+            );
+
+            await expectLater(
+              find.byGame<TestGame>(),
+              matchesGoldenFile('golden/multipliers/x4-lit.png'),
+            );
+          },
+        );
+
+        flameTester.testGameWidget(
+          'dimmed when bloc state is dimmed',
+          setUp: (game, tester) async {
+            await game.images.loadAll(assets);
+
+            whenListen(
+              bloc,
+              const Stream<MultiplierState>.empty(),
+              initialState: MultiplierState(
+                value: multiplierValue,
+                spriteState: MultiplierSpriteState.dimmed,
+              ),
+            );
+
+            final multiplier = Multiplier.test(
+              value: multiplierValue,
+              bloc: bloc,
+            );
+            await game.ensureAdd(multiplier);
+            await tester.pump();
+
+            game.camera.followVector2(Vector2.zero());
+          },
+          verify: (game, tester) async {
+            expect(
+              game
+                  .descendants()
+                  .whereType<MultiplierSpriteGroupComponent>()
+                  .first
+                  .current,
+              MultiplierSpriteState.dimmed,
+            );
+
+            await expectLater(
+              find.byGame<TestGame>(),
+              matchesGoldenFile('golden/multipliers/x4-dimmed.png'),
+            );
+          },
+        );
+      });
+
+      group('x5', () {
+        const multiplierValue = MultiplierValue.x5;
+
+        flameTester.testGameWidget(
+          'lit when bloc state is lit',
+          setUp: (game, tester) async {
+            await game.images.loadAll(assets);
+
+            whenListen(
+              bloc,
+              const Stream<MultiplierState>.empty(),
+              initialState: MultiplierState(
+                value: multiplierValue,
+                spriteState: MultiplierSpriteState.lit,
+              ),
+            );
+
+            final multiplier = Multiplier.test(
+              value: multiplierValue,
+              bloc: bloc,
+            );
+            await game.ensureAdd(multiplier);
+            await tester.pump();
+
+            game.camera.followVector2(Vector2.zero());
+          },
+          verify: (game, tester) async {
+            expect(
+              game
+                  .descendants()
+                  .whereType<MultiplierSpriteGroupComponent>()
+                  .first
+                  .current,
+              MultiplierSpriteState.lit,
+            );
+
+            await expectLater(
+              find.byGame<TestGame>(),
+              matchesGoldenFile('golden/multipliers/x5-lit.png'),
+            );
+          },
+        );
+
+        flameTester.testGameWidget(
+          'dimmed when bloc state is dimmed',
+          setUp: (game, tester) async {
+            await game.images.loadAll(assets);
+
+            whenListen(
+              bloc,
+              const Stream<MultiplierState>.empty(),
+              initialState: MultiplierState(
+                value: multiplierValue,
+                spriteState: MultiplierSpriteState.dimmed,
+              ),
+            );
+
+            final multiplier = Multiplier.test(
+              value: multiplierValue,
+              bloc: bloc,
+            );
+            await game.ensureAdd(multiplier);
+            await tester.pump();
+
+            game.camera.followVector2(Vector2.zero());
+          },
+          verify: (game, tester) async {
+            expect(
+              game
+                  .descendants()
+                  .whereType<MultiplierSpriteGroupComponent>()
+                  .first
+                  .current,
+              MultiplierSpriteState.dimmed,
+            );
+
+            await expectLater(
+              find.byGame<TestGame>(),
+              matchesGoldenFile('golden/multipliers/x5-dimmed.png'),
+            );
+          },
+        );
+      });
+
+      group('x6', () {
+        const multiplierValue = MultiplierValue.x6;
+
+        flameTester.testGameWidget(
+          'lit when bloc state is lit',
+          setUp: (game, tester) async {
+            await game.images.loadAll(assets);
+
+            whenListen(
+              bloc,
+              const Stream<MultiplierState>.empty(),
+              initialState: MultiplierState(
+                value: multiplierValue,
+                spriteState: MultiplierSpriteState.lit,
+              ),
+            );
+
+            final multiplier = Multiplier.test(
+              value: multiplierValue,
+              bloc: bloc,
+            );
+            await game.ensureAdd(multiplier);
+            await tester.pump();
+
+            game.camera.followVector2(Vector2.zero());
+          },
+          verify: (game, tester) async {
+            expect(
+              game
+                  .descendants()
+                  .whereType<MultiplierSpriteGroupComponent>()
+                  .first
+                  .current,
+              MultiplierSpriteState.lit,
+            );
+
+            await expectLater(
+              find.byGame<TestGame>(),
+              matchesGoldenFile('golden/multipliers/x6-lit.png'),
+            );
+          },
+        );
+
+        flameTester.testGameWidget(
+          'dimmed when bloc state is dimmed',
+          setUp: (game, tester) async {
+            await game.images.loadAll(assets);
+
+            whenListen(
+              bloc,
+              const Stream<MultiplierState>.empty(),
+              initialState: MultiplierState(
+                value: multiplierValue,
+                spriteState: MultiplierSpriteState.dimmed,
+              ),
+            );
+
+            final multiplier = Multiplier.test(
+              value: multiplierValue,
+              bloc: bloc,
+            );
+            await game.ensureAdd(multiplier);
+            await tester.pump();
+
+            game.camera.followVector2(Vector2.zero());
+          },
+          verify: (game, tester) async {
+            expect(
+              game
+                  .descendants()
+                  .whereType<MultiplierSpriteGroupComponent>()
+                  .first
+                  .current,
+              MultiplierSpriteState.dimmed,
+            );
+
+            await expectLater(
+              find.byGame<TestGame>(),
+              matchesGoldenFile('golden/multipliers/x6-dimmed.png'),
+            );
+          },
+        );
+      });
+    });
+
+    flameTester.test('closes bloc when removed', (game) async {
+      whenListen(
+        bloc,
+        const Stream<MultiplierState>.empty(),
+        initialState: MultiplierState(
+          value: MultiplierValue.x2,
+          spriteState: MultiplierSpriteState.dimmed,
+        ),
+      );
+      when(bloc.close).thenAnswer((_) async {});
+      final multiplier = Multiplier.test(value: MultiplierValue.x2, bloc: bloc);
+
+      await game.ensureAdd(multiplier);
+      game.remove(multiplier);
+      await game.ready();
+
+      verify(bloc.close).called(1);
+    });
+  });
+}

packages/pinball_components/test/src/components/multiplier_test.dart

@@ -1,483 +0,0 @@
-// ignore_for_file: cascade_invocations
-
-import 'package:flame/components.dart';
-import 'package:flame_test/flame_test.dart';
-import 'package:flutter_test/flutter_test.dart';
-import 'package:pinball_components/pinball_components.dart';
-
-import '../../helpers/helpers.dart';
-
-void main() {
-  group('MultiplierSpriteGroupComponent', () {
-    TestWidgetsFlutterBinding.ensureInitialized();
-    final assets = [
-      Assets.images.multiplier.x2.lit.keyName,
-      Assets.images.multiplier.x2.dimmed.keyName,
-      Assets.images.multiplier.x3.lit.keyName,
-      Assets.images.multiplier.x3.dimmed.keyName,
-      Assets.images.multiplier.x4.lit.keyName,
-      Assets.images.multiplier.x4.dimmed.keyName,
-      Assets.images.multiplier.x5.lit.keyName,
-      Assets.images.multiplier.x5.dimmed.keyName,
-      Assets.images.multiplier.x6.lit.keyName,
-      Assets.images.multiplier.x6.dimmed.keyName,
-    ];
-    final flameTester = FlameTester(() => TestGame(assets));
-
-    group('renders correctly', () {
-      flameTester.testGameWidget(
-        'x2 active',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-          final multiplier = Multiplier(
-            value: MultiplierValue.x2,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-
-          multiplier.toggle(2);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.lit,
-          );
-
-          await expectLater(
-            find.byGame<TestGame>(),
-            matchesGoldenFile('golden/multipliers/x2-active.png'),
-          );
-        },
-      );
-
-      flameTester.testGameWidget(
-        'x2 inactive',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-
-          final multiplier = Multiplier(
-            value: MultiplierValue.x2,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.dimmed,
-          );
-
-          await expectLater(
-            find.byGame<TestGame>(),
-            matchesGoldenFile('golden/multipliers/x2-inactive.png'),
-          );
-        },
-      );
-
-      flameTester.testGameWidget(
-        'x2 deactivated when different multiply value',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-
-          final multiplier = Multiplier(
-            value: MultiplierValue.x2,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-          multiplier.toggle(1);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.dimmed,
-          );
-        },
-      );
-
-      flameTester.testGameWidget(
-        'x3 active',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-
-          final multiplier = Multiplier(
-            value: MultiplierValue.x3,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-
-          multiplier.toggle(3);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.lit,
-          );
-
-          await expectLater(
-            find.byGame<TestGame>(),
-            matchesGoldenFile('golden/multipliers/x3-active.png'),
-          );
-        },
-      );
-
-      flameTester.testGameWidget(
-        'x3 inactive',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-
-          final multiplier = Multiplier(
-            value: MultiplierValue.x3,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.dimmed,
-          );
-
-          await expectLater(
-            find.byGame<TestGame>(),
-            matchesGoldenFile('golden/multipliers/x3-inactive.png'),
-          );
-        },
-      );
-
-      flameTester.testGameWidget(
-        'x3 deactivated when different multiply value',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-
-          final multiplier = Multiplier(
-            value: MultiplierValue.x3,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-          multiplier.toggle(1);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.dimmed,
-          );
-        },
-      );
-
-      flameTester.testGameWidget(
-        'x4 active',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-
-          final multiplier = Multiplier(
-            value: MultiplierValue.x4,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-
-          multiplier.toggle(4);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.lit,
-          );
-
-          await expectLater(
-            find.byGame<TestGame>(),
-            matchesGoldenFile('golden/multipliers/x4-active.png'),
-          );
-        },
-      );
-
-      flameTester.testGameWidget(
-        'x4 inactive',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-
-          final multiplier = Multiplier(
-            value: MultiplierValue.x4,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.dimmed,
-          );
-
-          await expectLater(
-            find.byGame<TestGame>(),
-            matchesGoldenFile('golden/multipliers/x4-inactive.png'),
-          );
-        },
-      );
-
-      flameTester.testGameWidget(
-        'x4 deactivated when different multiply value',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-
-          final multiplier = Multiplier(
-            value: MultiplierValue.x4,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-          multiplier.toggle(1);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.dimmed,
-          );
-        },
-      );
-
-      flameTester.testGameWidget(
-        'x5 active',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-
-          final multiplier = Multiplier(
-            value: MultiplierValue.x5,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-
-          multiplier.toggle(5);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.lit,
-          );
-
-          await expectLater(
-            find.byGame<TestGame>(),
-            matchesGoldenFile('golden/multipliers/x5-active.png'),
-          );
-        },
-      );
-
-      flameTester.testGameWidget(
-        'x5 inactive',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-
-          final multiplier = Multiplier(
-            value: MultiplierValue.x5,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.dimmed,
-          );
-
-          await expectLater(
-            find.byGame<TestGame>(),
-            matchesGoldenFile('golden/multipliers/x5-inactive.png'),
-          );
-        },
-      );
-
-      flameTester.testGameWidget(
-        'x5 deactivated when different multiply value',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-
-          final multiplier = Multiplier(
-            value: MultiplierValue.x5,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-          multiplier.toggle(1);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.dimmed,
-          );
-        },
-      );
-
-      flameTester.testGameWidget(
-        'x6 active',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-
-          final multiplier = Multiplier(
-            value: MultiplierValue.x6,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-
-          multiplier.toggle(6);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.lit,
-          );
-
-          await expectLater(
-            find.byGame<TestGame>(),
-            matchesGoldenFile('golden/multipliers/x6-active.png'),
-          );
-        },
-      );
-
-      flameTester.testGameWidget(
-        'x6 inactive',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-
-          final multiplier = Multiplier(
-            value: MultiplierValue.x6,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.dimmed,
-          );
-
-          await expectLater(
-            find.byGame<TestGame>(),
-            matchesGoldenFile('golden/multipliers/x6-inactive.png'),
-          );
-        },
-      );
-
-      flameTester.testGameWidget(
-        'x6 deactivated when different multiply value',
-        setUp: (game, tester) async {
-          await game.images.loadAll(assets);
-
-          final multiplier = Multiplier(
-            value: MultiplierValue.x6,
-            position: Vector2.zero(),
-          );
-          await game.ensureAdd(multiplier);
-          multiplier.toggle(1);
-          await tester.pump();
-
-          game.camera.followVector2(Vector2.zero());
-        },
-        verify: (game, tester) async {
-          expect(
-            game
-                .descendants()
-                .whereType<MultiplierSpriteGroupComponent>()
-                .first
-                .current,
-            MultiplierSpriteState.dimmed,
-          );
-        },
-      );
-    });
-  });
-}