Format Dart files

Author: brandonp2412

lib/screens/settings_screen.dart

@@ -219,8 +219,7 @@ class _SettingsScreenState extends State<SettingsScreen> {
                 ),
                 child: Row(children: [
                   Expanded(
-                      child: Text(
-                          _themeModeLabel(widget.settings.themeMode))),
+                      child: Text(_themeModeLabel(widget.settings.themeMode))),
                   const Icon(Icons.arrow_drop_down, size: 20),
                 ]),
               ),
@@ -237,9 +236,7 @@ class _SettingsScreenState extends State<SettingsScreen> {
                   alignment: Alignment.centerLeft,
                 ),
                 child: Row(children: [
-                  Expanded(
-                      child:
-                          Text(_styleLabel(widget.settings.style))),
+                  Expanded(child: Text(_styleLabel(widget.settings.style))),
                   const Icon(Icons.arrow_drop_down, size: 20),
                 ]),
               ),
@@ -303,7 +300,8 @@ class _SettingsScreenState extends State<SettingsScreen> {
               ),
             ),
             _SectionHeader(label: 'Instructions', colorScheme: colorScheme),
-            _InstructionsCard(colorScheme: colorScheme, style: widget.settings.style),
+            _InstructionsCard(
+                colorScheme: colorScheme, style: widget.settings.style),
             const SizedBox(height: 8),
           ],
         ),

test/audio_service_test.dart

@@ -61,6 +61,46 @@ void main() {
     return (mock, stateController);
   }
 
+  group('AudioService — musicEnabled flag', () {
+    test(
+      'startMusic does not call play() when musicEnabled is false',
+      () async {
+        final (mockMusic, stateController) = makeMusicPlayer();
+
+        final service = AudioService(
+          musicEnabled: false,
+          musicPlayer: mockMusic,
+          sfxPlayerFactory: makeSfxPlayer,
+        );
+        await service.init();
+        await service.startMusic();
+
+        verifyNever(() => mockMusic.play(any()));
+
+        await stateController.close();
+      },
+    );
+
+    test(
+      'startMusic calls play() when musicEnabled is true',
+      () async {
+        final (mockMusic, stateController) = makeMusicPlayer();
+
+        final service = AudioService(
+          musicEnabled: true,
+          musicPlayer: mockMusic,
+          sfxPlayerFactory: makeSfxPlayer,
+        );
+        await service.init();
+        await service.startMusic();
+
+        verify(() => mockMusic.play(any())).called(1);
+
+        await stateController.close();
+      },
+    );
+  });
+
   group('AudioService — unexpected music pause recovery', () {
     test(
       'calls resume() (not play()) when the music player is externally paused',

test/game_logic_test.dart

@@ -246,27 +246,95 @@ void main() {
       expect(expectedGhostY, greaterThanOrEqualTo(initialY));
     });
 
-    test('should update score and level when lines are cleared', () {
+    test('dropPiece should be blocked during grace period', () {
       gameLogic.startGame();
 
-      // Fill bottom row except one column
-      for (int col = 0; col < GameConstants.boardWidth - 1; col++) {
-        gameLogic.board[GameConstants.boardHeight +
-            GameConstants.previewRows -
-            1][col] = Colors.red;
-      }
+      // Grace period is always active immediately after a piece spawns
+      expect(gameLogic.isNewPieceGracePeriod, true);
+
+      gameLogic.dropPiece(); // Should return early without placing anything
+
+      // The board should still be empty — no blocks placed
+      bool boardHasPlacedBlocks =
+          gameLogic.board.any((row) => row.any((cell) => cell != null));
+      expect(boardHasPlacedBlocks, false,
+          reason:
+              'Hard drop during grace period must not place the piece on the board');
+    });
+
+    test('should start line clear animation when a full row is detected', () {
+      gameLogic.startGame();
 
-      // Place a piece to complete the line
-      gameLogic.board[GameConstants.boardHeight + GameConstants.previewRows - 1]
-          [GameConstants.boardWidth - 1] = Colors.blue;
+      // Fill the bottom row completely
+      final bottomRow =
+          GameConstants.boardHeight + GameConstants.previewRows - 1;
+      for (int col = 0; col < GameConstants.boardWidth; col++) {
+        gameLogic.board[bottomRow][col] = Colors.red;
+      }
 
       gameLogic.clearLines();
 
-      // Wait for animation to complete
       expect(gameLogic.clearingLines.length, 1);
       expect(gameLogic.isAnimatingClear, true);
     });
 
+    test('should update score correctly after single line clear', () async {
+      gameLogic.startGame();
+
+      final bottomRow =
+          GameConstants.boardHeight + GameConstants.previewRows - 1;
+      for (int col = 0; col < GameConstants.boardWidth; col++) {
+        gameLogic.board[bottomRow][col] = Colors.red;
+      }
+
+      gameLogic.clearLines();
+      // Wait for the 350 ms clear animation timer to fire
+      await Future.delayed(const Duration(milliseconds: 400));
+
+      expect(gameLogic.score, GameConstants.lineClearScores[1] * 1); // 100
+      expect(gameLogic.linesCleared, 1);
+      expect(gameLogic.isAnimatingClear, false);
+    });
+
+    test('should award full TETRIS bonus for clearing 4 lines at once',
+        () async {
+      gameLogic.startGame();
+
+      final totalRows = GameConstants.boardHeight + GameConstants.previewRows;
+      for (int row = totalRows - 4; row < totalRows; row++) {
+        for (int col = 0; col < GameConstants.boardWidth; col++) {
+          gameLogic.board[row][col] = Colors.red;
+        }
+      }
+
+      gameLogic.clearLines();
+      await Future.delayed(const Duration(milliseconds: 400));
+
+      expect(gameLogic.score, GameConstants.lineClearScores[4] * 1); // 800
+      expect(gameLogic.linesCleared, 4);
+      expect(gameLogic.clearBonusLabel, 'TETRIS!');
+    });
+
+    test('should increase level after clearing linesPerLevel lines', () async {
+      gameLogic.startGame();
+
+      // Fill exactly linesPerLevel full rows
+      final totalRows = GameConstants.boardHeight + GameConstants.previewRows;
+      for (int row = totalRows - GameConstants.linesPerLevel;
+          row < totalRows;
+          row++) {
+        for (int col = 0; col < GameConstants.boardWidth; col++) {
+          gameLogic.board[row][col] = Colors.red;
+        }
+      }
+
+      gameLogic.clearLines();
+      await Future.delayed(const Duration(milliseconds: 400));
+
+      expect(gameLogic.linesCleared, GameConstants.linesPerLevel);
+      expect(gameLogic.level, 2);
+    });
+
     test('should detect game over correctly', () {
       gameLogic.startGame();
 
@@ -286,6 +354,90 @@ void main() {
       expect(gameLogic.isGameRunning, false);
     });
 
+    test('should pause and resume game correctly', () {
+      gameLogic.startGame();
+      expect(gameLogic.isPaused, false);
+      expect(gameLogic.isGameRunning, true);
+
+      gameLogic.pauseGame();
+      expect(gameLogic.isPaused, true);
+      expect(gameLogic.isGameRunning, true); // still running, just paused
+      expect(gameLogic.isGameOver, false);
+
+      gameLogic.resumeGame();
+      expect(gameLogic.isPaused, false);
+      expect(gameLogic.isGameRunning, true);
+    });
+
+    test('pauseGame should be idempotent', () {
+      gameLogic.startGame();
+      gameLogic.pauseGame();
+      gameLogic.pauseGame(); // second call should be a no-op
+      expect(gameLogic.isPaused, true);
+    });
+
+    test('should receive garbage rows from opponent', () {
+      gameLogic.startGame();
+
+      final totalRows = GameConstants.boardHeight + GameConstants.previewRows;
+      // Board bottom should be empty initially
+      expect(gameLogic.board[totalRows - 1][0], isNull);
+
+      gameLogic.receiveGarbage(2);
+
+      // Count filled vs gap cells in the bottom 2 rows
+      int filledCells = 0;
+      int gapCells = 0;
+      for (int row = totalRows - 2; row < totalRows; row++) {
+        for (int col = 0; col < GameConstants.boardWidth; col++) {
+          if (gameLogic.board[row][col] != null) {
+            filledCells++;
+          } else {
+            gapCells++;
+          }
+        }
+      }
+
+      // Each garbage row has exactly one gap column
+      expect(filledCells, (GameConstants.boardWidth - 1) * 2);
+      expect(gapCells, 2);
+    });
+
+    test('receiveGarbage should be a no-op when lines <= 0', () {
+      gameLogic.startGame();
+      final boardBefore =
+          gameLogic.board.map((row) => List<Color?>.from(row)).toList();
+
+      gameLogic.receiveGarbage(0);
+
+      for (int row = 0; row < gameLogic.board.length; row++) {
+        expect(gameLogic.board[row], equals(boardBefore[row]));
+      }
+    });
+
+    test('should export board snapshot with correct dimensions', () {
+      gameLogic.startGame();
+
+      final snapshot = gameLogic.exportBoardSnapshot();
+
+      // Snapshot covers only the visible board (no preview rows)
+      expect(
+        snapshot.length,
+        GameConstants.boardWidth * GameConstants.boardHeight,
+      );
+      // All values must be valid palette indices
+      expect(snapshot.every((cell) => cell >= 0 && cell <= 8), true);
+    });
+
+    test('exportBoardSnapshot should include the current piece', () {
+      gameLogic.startGame();
+
+      final snapshot = gameLogic.exportBoardSnapshot();
+
+      // Current piece should appear somewhere in the snapshot as a non-zero index
+      expect(snapshot.any((cell) => cell > 0), true);
+    });
+
     test('should get board with current piece correctly', () {
       gameLogic.startGame();
 

test/settings_provider_test.dart

@@ -0,0 +1,110 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'package:block_drop/settings/settings_provider.dart';
+
+void main() {
+  group('SettingsProvider', () {
+    setUp(() {
+      SharedPreferences.setMockInitialValues({});
+    });
+
+    test('starts with correct default values', () {
+      final settings = SettingsProvider();
+
+      expect(settings.themeMode, AppThemeMode.system);
+      expect(settings.style, AppStyle.classic);
+      expect(settings.musicEnabled, false);
+      expect(settings.sfxEnabled, false);
+      expect(settings.highScore, 0);
+    });
+
+    test('updateHighScore only updates when the new score is higher', () async {
+      final settings = SettingsProvider();
+
+      await settings.updateHighScore(500);
+      expect(settings.highScore, 500);
+
+      await settings.updateHighScore(200); // lower — should be ignored
+      expect(settings.highScore, 500);
+
+      await settings.updateHighScore(1000); // higher — should update
+      expect(settings.highScore, 1000);
+    });
+
+    test('updateHighScore does not update when score equals current high score',
+        () async {
+      final settings = SettingsProvider();
+
+      await settings.updateHighScore(300);
+      expect(settings.highScore, 300);
+
+      await settings.updateHighScore(300); // equal — should not trigger notify
+      expect(settings.highScore, 300);
+    });
+
+    test('isBlackMode is true only for AppThemeMode.black', () async {
+      final settings = SettingsProvider();
+
+      expect(settings.isBlackMode, false); // default is system
+
+      await settings.setThemeMode(AppThemeMode.black);
+      expect(settings.isBlackMode, true);
+
+      await settings.setThemeMode(AppThemeMode.dark);
+      expect(settings.isBlackMode, false);
+
+      await settings.setThemeMode(AppThemeMode.light);
+      expect(settings.isBlackMode, false);
+
+      await settings.setThemeMode(AppThemeMode.system);
+      expect(settings.isBlackMode, false);
+    });
+
+    test('flutterThemeMode maps each AppThemeMode to the correct ThemeMode',
+        () async {
+      final settings = SettingsProvider();
+
+      await settings.setThemeMode(AppThemeMode.system);
+      expect(settings.flutterThemeMode, ThemeMode.system);
+
+      await settings.setThemeMode(AppThemeMode.light);
+      expect(settings.flutterThemeMode, ThemeMode.light);
+
+      await settings.setThemeMode(AppThemeMode.dark);
+      expect(settings.flutterThemeMode, ThemeMode.dark);
+
+      // Black AMOLED mode piggybacks on dark theme
+      await settings.setThemeMode(AppThemeMode.black);
+      expect(settings.flutterThemeMode, ThemeMode.dark);
+    });
+
+    test('setMusicEnabled and setSfxEnabled update in-memory state', () async {
+      final settings = SettingsProvider();
+
+      expect(settings.musicEnabled, false);
+      expect(settings.sfxEnabled, false);
+
+      await settings.setMusicEnabled(true);
+      expect(settings.musicEnabled, true);
+
+      await settings.setSfxEnabled(true);
+      expect(settings.sfxEnabled, true);
+
+      await settings.setMusicEnabled(false);
+      expect(settings.musicEnabled, false);
+    });
+
+    test('setStyle updates the current style', () async {
+      final settings = SettingsProvider();
+
+      expect(settings.style, AppStyle.classic);
+
+      await settings.setStyle(AppStyle.neon);
+      expect(settings.style, AppStyle.neon);
+
+      await settings.setStyle(AppStyle.retro);
+      expect(settings.style, AppStyle.retro);
+    });
+  });
+}