test: fixed tests after Layer mixin changes

test/game/components/layer_test.dart

@@ -1,8 +1,127 @@
 // ignore_for_file: cascade_invocations
+import 'dart:math' as math;
+
+import 'package:flame_forge2d/flame_forge2d.dart';
+import 'package:flame_test/flame_test.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:pinball/game/game.dart';
 
+class TestBodyComponent extends BodyComponent with Layered {
+  @override
+  Body createBody() {
+    final fixtureDef = FixtureDef(CircleShape());
+    return world.createBody(BodyDef())..createFixture(fixtureDef);
+  }
+}
+
 void main() {
+  final flameTester = FlameTester(Forge2DGame.new);
+  group('Layered', () {
+    void _expectLayerOnFixtures({
+      required List<Fixture> fixtures,
+      required Layer layer,
+    }) {
+      for (final fixture in fixtures) {
+        expect(
+          fixture.filterData.categoryBits,
+          equals(layer.maskBits),
+        );
+        expect(fixture.filterData.maskBits, equals(layer.maskBits));
+      }
+    }
+
+    flameTester.test('TestBodyComponent has fixtures', (game) async {
+      final component = TestBodyComponent();
+      await game.ensureAdd(component);
+      expect(component.body.fixtures.length, greaterThan(0));
+    });
+
+    test('correctly sets and gets', () {
+      final component = TestBodyComponent()..layer = Layer.jetpack;
+      expect(component.layer, Layer.jetpack);
+    });
+
+    flameTester.test(
+      'layers correctly before being loaded',
+      (game) async {
+        const expectedLayer = Layer.jetpack;
+        final component = TestBodyComponent()..layer = expectedLayer;
+        await game.ensureAdd(component);
+        // TODO(alestiago): modify once component.loaded is available.
+        await component.mounted;
+
+        _expectLayerOnFixtures(
+          fixtures: component.body.fixtures,
+          layer: expectedLayer,
+        );
+      },
+    );
+
+    flameTester.test(
+      'layers correctly before being loaded '
+      'when multiple different sets',
+      (game) async {
+        const expectedLayer = Layer.launcher;
+        final component = TestBodyComponent()..layer = Layer.jetpack;
+
+        expect(component.layer, isNot(equals(expectedLayer)));
+        component.layer = expectedLayer;
+
+        await game.ensureAdd(component);
+        // TODO(alestiago): modify once component.loaded is available.
+        await component.mounted;
+
+        _expectLayerOnFixtures(
+          fixtures: component.body.fixtures,
+          layer: expectedLayer,
+        );
+      },
+    );
+
+    flameTester.test(
+      'layers correctly after being loaded',
+      (game) async {
+        const expectedLayer = Layer.jetpack;
+        final component = TestBodyComponent();
+        await game.ensureAdd(component);
+        component.layer = expectedLayer;
+        _expectLayerOnFixtures(
+          fixtures: component.body.fixtures,
+          layer: expectedLayer,
+        );
+      },
+    );
+
+    flameTester.test(
+      'layers correctly after being loaded '
+      'when multiple different sets',
+      (game) async {
+        const expectedLayer = Layer.launcher;
+        final component = TestBodyComponent();
+        await game.ensureAdd(component);
+
+        component.layer = Layer.jetpack;
+        expect(component.layer, isNot(equals(expectedLayer)));
+        component.layer = expectedLayer;
+
+        _expectLayerOnFixtures(
+          fixtures: component.body.fixtures,
+          layer: expectedLayer,
+        );
+      },
+    );
+
+    flameTester.test(
+      'defaults to Layer.all '
+      'when no layer is given',
+      (game) async {
+        final component = TestBodyComponent();
+        await game.ensureAdd(component);
+        expect(component.layer, equals(Layer.all));
+      },
+    );
+  });
+
   group('Layer', () {
     test('has four values', () {
       expect(Layer.values.length, equals(5));
@@ -18,6 +137,13 @@ void main() {
       expect(Layer.launcher.maskBits, isNot(equals(Layer.board.maskBits)));
     });
 
+    test('ensure all maskBits are 16 bits max size', () {
+      final maxMaskBitSize = math.pow(2, 16);
+      for (final layer in Layer.values) {
+        expect(layer.maskBits, isNot(greaterThan(maxMaskBitSize)));
+      }
+    });
+
     test('all type has 0xFFFF maskBits', () {
       expect(Layer.all.maskBits, equals(0xFFFF));
     });

test/game/components/pathway_test.dart

@@ -161,6 +161,8 @@ void main() {
             )..layer = layer;
             await game.ready();
             await game.ensureAdd(pathway);
+            // TODO(alestiago): modify once component.loaded is available.
+            await pathway.mounted;
 
             for (final fixture in pathway.body.fixtures) {
               expect(fixture, isA<Fixture>());

test/game/components/ramp_opening_test.dart

@@ -156,6 +156,8 @@ void main() {
 
             await game.ready();
             await game.ensureAdd(ramp);
+            // TODO(alestiago): modify once component.loaded is available.
+            await ramp.mounted;
 
             final fixture = ramp.body.fixtures[0];
             expect(