[verified] Publish ReelBox source under GPLv3

test/player_lifecycle_regression_test.dart

@@ -0,0 +1,96 @@
+import 'dart:async';
+
+import 'package:flutter_test/flutter_test.dart';
+import 'package:reelbox/media/media_helpers.dart';
+
+void main() {
+  for (final pendingStep in [0, 1, 2]) {
+    test(
+      'dispose during setup step $pendingStep cancels later writes; restore is last',
+      () async {
+        final lifecycle = PlaybackLifecycle();
+        final entered = Completer<void>();
+        final release = Completer<void>();
+        final events = <String>[];
+        final setup = lifecycle.setup([
+          for (var i = 0; i < 3; i++)
+            () async {
+              if (i == pendingStep) {
+                entered.complete();
+                await release.future;
+              }
+              events.add('setup:$i');
+            },
+        ]);
+        await entered.future;
+        final restore = lifecycle.dispose(() async => events.add('restore'));
+        release.complete();
+        expect(await setup, isFalse);
+        await restore;
+        expect(events, [
+          for (var i = 0; i <= pendingStep; i++) 'setup:$i',
+          'restore',
+        ]);
+      },
+    );
+  }
+  test('dispose during save prevents any player open dispatch', () async {
+    final lifecycle = PlaybackLifecycle();
+    final save = Completer<void>();
+    var opens = 0;
+    final opening = lifecycle.open(
+      save: () => save.future,
+      dispatch: (_) async {
+        opens++;
+      },
+    );
+    await lifecycle.dispose(() async {});
+    save.complete();
+    expect(await opening, isFalse);
+    expect(opens, 0);
+  });
+  test('newer open wins even when an older save completes last', () async {
+    final lifecycle = PlaybackLifecycle();
+    final save = Completer<void>();
+    final opened = <String>[];
+    final older = lifecycle.open(
+      save: () => save.future,
+      dispatch: (_) async => opened.add('old'),
+    );
+    expect(
+      await lifecycle.open(
+        save: () async {},
+        dispatch: (_) async => opened.add('new'),
+      ),
+      isTrue,
+    );
+    save.complete();
+    expect(await older, isFalse);
+    expect(opened, ['new']);
+  });
+  test('disposed lifecycle rejects new setup and open work', () async {
+    final lifecycle = PlaybackLifecycle();
+    await lifecycle.dispose(() async {});
+    var calls = 0;
+    expect(
+      await lifecycle.setup([
+        () async {
+          calls++;
+        },
+      ]),
+      isFalse,
+    );
+    expect(
+      await lifecycle.open(
+        save: () async {
+          calls++;
+        },
+        dispatch: (_) async {
+          calls++;
+        },
+      ),
+      isFalse,
+    );
+    expect(calls, 0);
+  });
+}