From d927fe03ddc068c43b4a44910008bf2fff2080c3 Mon Sep 17 00:00:00 2001
From: Alexander Sandor <alexander@serverpod.dev>
Date: Fri, 14 Feb 2025 15:28:35 +0100
Subject: [PATCH 1/3] test: Add test to validate wrap around in select list
 works.

---
 test/prompts/multiple_select_test.dart | 30 ++++++++++++++++++++++++++
 test/prompts/select_test.dart          | 25 +++++++++++++++++++++
 2 files changed, 55 insertions(+)

diff --git a/test/prompts/multiple_select_test.dart b/test/prompts/multiple_select_test.dart
index 6177154..16d2b64 100644
--- a/test/prompts/multiple_select_test.dart
+++ b/test/prompts/multiple_select_test.dart
@@ -245,4 +245,34 @@ ${underline('(●) Option 2')}
 Press [Space] to toggle selection, [Enter] to confirm.
 ''');
   });
+
+  test(
+      'Given multiple select prompt with multiple options '
+      'when moving past the last option and pressing Enter '
+      'then first option is selected', () async {
+    late Future<List<Option>> result;
+    var options = [Option('Option 1'), Option('Option 2'), Option('Option 3')];
+
+    await collectOutput(
+      keyInputs: [
+        ...arrowDownSequence, // Move to Option 2
+        ...arrowDownSequence, // Move to Option 3
+        ...arrowDownSequence, // Move to Option 1
+        KeyCodes.space, // Select Option 1
+        KeyCodes.enterCR
+      ],
+      () {
+        result = multiselect(
+          'Choose multiple options:',
+          options: options,
+          logger: logger,
+        );
+      },
+    );
+
+    await expectLater(
+      result,
+      completion(containsAllOptions([Option('Option 1')])),
+    );
+  });
 }
diff --git a/test/prompts/select_test.dart b/test/prompts/select_test.dart
index b615726..b492693 100644
--- a/test/prompts/select_test.dart
+++ b/test/prompts/select_test.dart
@@ -173,4 +173,29 @@ ${underline('(●) Option 2')}
 Press [Enter] to confirm.
 ''');
   });
+
+  test(
+      'Given select prompt with multiple options '
+      'when moving past the last option '
+      'then should wrap around to the first option', () async {
+    late Future<Option> result;
+    var options = [Option('Option 1'), Option('Option 2'), Option('Option 3')];
+
+    await collectOutput(
+      keyInputs: [
+        ...arrowDownSequence, // Go to option 2
+        ...arrowDownSequence, // Go to option 3
+        ...arrowDownSequence, // Go to option 1
+        KeyCodes.enterCR
+      ],
+      () {
+        result = select('Choose an option:', options: options, logger: logger);
+      },
+    );
+
+    await expectLater(
+      result,
+      completion(equalsOption(Option('Option 1'))),
+    );
+  });
 }

From 2225aeb9547fc364cf796ba518ebfcce485f57d6 Mon Sep 17 00:00:00 2001
From: Alexander Sandor <alexander@serverpod.dev>
Date: Fri, 14 Feb 2025 15:46:02 +0100
Subject: [PATCH 2/3] chore: format with dart 3.7.0

---
 example/main.dart                             |   5 +-
 lib/src/analytics/analytics.dart              |  34 ++-
 .../better_command_runner/better_command.dart |   8 +-
 .../better_command_runner.dart                |  83 +++---
 lib/src/logger/helpers/progress.dart          |   9 +-
 lib/src/logger/logger.dart                    |  33 +--
 lib/src/logger/loggers/std_out_logger.dart    |  51 +---
 lib/src/package_version/package_version.dart  |  10 +-
 lib/src/package_version/pub_api_client.dart   |   4 +-
 lib/src/prompts/confirm.dart                  |   7 +-
 lib/src/prompts/select.dart                   |  42 ++-
 .../better_command_runner/analytics_test.dart | 262 ++++++++++--------
 test/better_command_runner/command_test.dart  |  62 ++---
 .../default_flags_test.dart                   |  66 +++--
 .../exit_exceptions_test.dart                 |  72 ++---
 test/better_command_runner/logging_test.dart  |  12 +-
 .../parse_log_level_test.dart                 |  13 +-
 test/better_command_test.dart                 |  18 +-
 .../generate_markdown_test.dart               |  98 +++----
 .../local_storage_manager_test.dart           |  36 ++-
 test/package_version_test.dart                | 193 +++++++------
 test/prompts/confirm_test.dart                | 229 +++++----------
 test/prompts/input_test.dart                  | 102 ++-----
 test/prompts/multiple_select_test.dart        | 144 ++++------
 test/prompts/select_test.dart                 |  98 ++-----
 test/pub_api_client_test.dart                 | 205 +++++++-------
 test/test_utils/io_helper.dart                |   7 +-
 test/test_utils/mock_stdin.dart               |  67 +++--
 .../test_utils/prompts/key_code_sequence.dart |   4 +-
 test/test_utils/prompts/option_matcher.dart   |   5 +-
 30 files changed, 876 insertions(+), 1103 deletions(-)

diff --git a/example/main.dart b/example/main.dart
index 26b3157..7669ec5 100644
--- a/example/main.dart
+++ b/example/main.dart
@@ -11,9 +11,6 @@ void main() async {
   );
   await logger.progress(
     'A progress message',
-    () async => Future.delayed(
-      const Duration(seconds: 3),
-      () => true,
-    ),
+    () async => Future.delayed(const Duration(seconds: 3), () => true),
   );
 }
diff --git a/lib/src/analytics/analytics.dart b/lib/src/analytics/analytics.dart
index d0806d9..fb349da 100644
--- a/lib/src/analytics/analytics.dart
+++ b/lib/src/analytics/analytics.dart
@@ -10,9 +10,7 @@ abstract interface class Analytics {
   void cleanUp();
 
   /// Track an event.
-  void track({
-    required String event,
-  });
+  void track({required String event});
 }
 
 /// Analytics service for MixPanel.
@@ -26,17 +24,15 @@ class MixPanelAnalytics implements Analytics {
     required String uniqueUserId,
     required String projectToken,
     required String version,
-  })  : _uniqueUserId = uniqueUserId,
-        _projectToken = projectToken,
-        _version = version;
+  }) : _uniqueUserId = uniqueUserId,
+       _projectToken = projectToken,
+       _version = version;
 
   @override
   void cleanUp() {}
 
   @override
-  void track({
-    required String event,
-  }) {
+  void track({required String event}) {
     var payload = jsonEncode({
       'event': event,
       'properties': {
@@ -46,7 +42,7 @@ class MixPanelAnalytics implements Analytics {
         'dart_version': Platform.version,
         'is_ci': ci.isCI,
         'version': _version,
-      }
+      },
     });
 
     _quietPost(payload);
@@ -66,14 +62,16 @@ class MixPanelAnalytics implements Analytics {
 
   Future<void> _quietPost(String payload) async {
     try {
-      await http.post(
-        Uri.parse(_endpoint),
-        body: 'data=$payload',
-        headers: {
-          'Accept': 'text/plain',
-          'Content-Type': 'application/x-www-form-urlencoded',
-        },
-      ).timeout(const Duration(seconds: 2));
+      await http
+          .post(
+            Uri.parse(_endpoint),
+            body: 'data=$payload',
+            headers: {
+              'Accept': 'text/plain',
+              'Content-Type': 'application/x-www-form-urlencoded',
+            },
+          )
+          .timeout(const Duration(seconds: 2));
     } catch (e) {
       return;
     }
diff --git a/lib/src/better_command_runner/better_command.dart b/lib/src/better_command_runner/better_command.dart
index b26a661..b051b63 100644
--- a/lib/src/better_command_runner/better_command.dart
+++ b/lib/src/better_command_runner/better_command.dart
@@ -6,11 +6,9 @@ abstract class BetterCommand extends Command {
   final PassMessage? _logInfo;
   final ArgParser _argParser;
 
-  BetterCommand({
-    PassMessage? logInfo,
-    int? wrapTextColumn,
-  })  : _logInfo = logInfo,
-        _argParser = ArgParser(usageLineLength: wrapTextColumn);
+  BetterCommand({PassMessage? logInfo, int? wrapTextColumn})
+    : _logInfo = logInfo,
+      _argParser = ArgParser(usageLineLength: wrapTextColumn);
 
   @override
   ArgParser get argParser => _argParser;
diff --git a/lib/src/better_command_runner/better_command_runner.dart b/lib/src/better_command_runner/better_command_runner.dart
index d918c9c..46baf9b 100644
--- a/lib/src/better_command_runner/better_command_runner.dart
+++ b/lib/src/better_command_runner/better_command_runner.dart
@@ -5,9 +5,7 @@ import 'package:args/command_runner.dart';
 import 'package:cli_tools/src/better_command_runner/exit_exception.dart';
 
 /// A function type for executing code before running a command.
-typedef OnBeforeRunCommand = Future<void> Function(
-  BetterCommandRunner runner,
-);
+typedef OnBeforeRunCommand = Future<void> Function(BetterCommandRunner runner);
 
 /// A function type for passing log messages.
 typedef PassMessage = void Function(String message);
@@ -16,10 +14,11 @@ typedef PassMessage = void Function(String message);
 /// The [logLevel] is the log level to set.
 /// The [commandName] is the name of the command if custom rules for log
 /// levels are needed.
-typedef SetLogLevel = void Function({
-  required CommandRunnerLogLevel parsedLogLevel,
-  String? commandName,
-});
+typedef SetLogLevel =
+    void Function({
+      required CommandRunnerLogLevel parsedLogLevel,
+      String? commandName,
+    });
 
 /// A function type for tracking events.
 typedef OnAnalyticsEvent = void Function(String event);
@@ -64,18 +63,19 @@ class BetterCommandRunner extends CommandRunner {
     OnBeforeRunCommand? onBeforeRunCommand,
     OnAnalyticsEvent? onAnalyticsEvent,
     int? wrapTextColumn,
-  })  : _logError = logError,
-        _logInfo = logInfo,
-        _onBeforeRunCommand = onBeforeRunCommand,
-        _setLogLevel = setLogLevel,
-        _onAnalyticsEvent = onAnalyticsEvent,
-        _argParser = ArgParser(usageLineLength: wrapTextColumn) {
+  }) : _logError = logError,
+       _logInfo = logInfo,
+       _onBeforeRunCommand = onBeforeRunCommand,
+       _setLogLevel = setLogLevel,
+       _onAnalyticsEvent = onAnalyticsEvent,
+       _argParser = ArgParser(usageLineLength: wrapTextColumn) {
     argParser.addFlag(
       BetterCommandRunnerFlags.quiet,
       abbr: BetterCommandRunnerFlags.quietAbbr,
       defaultsTo: false,
       negatable: false,
-      help: 'Suppress all cli output. Is overridden by '
+      help:
+          'Suppress all cli output. Is overridden by '
           ' -${BetterCommandRunnerFlags.verboseAbbr}, --${BetterCommandRunnerFlags.verbose}.',
     );
 
@@ -84,7 +84,8 @@ class BetterCommandRunner extends CommandRunner {
       abbr: BetterCommandRunnerFlags.verboseAbbr,
       defaultsTo: false,
       negatable: false,
-      help: 'Prints additional information useful for development. '
+      help:
+          'Prints additional information useful for development. '
           'Overrides --${BetterCommandRunnerFlags.quietAbbr}, --${BetterCommandRunnerFlags.quiet}.',
     );
 
@@ -140,31 +141,33 @@ class BetterCommandRunner extends CommandRunner {
       _onAnalyticsEvent = null;
     }
 
-    unawaited(Future(() async {
-      var command = topLevelResults.command;
-      if (command != null) {
-        // Command name can only be null for top level results.
-        // But since we are taking the name of a command from the top level
-        // results there should always be a name specified.
-        assert(command.name != null, 'Command name should never be null.');
-        _onAnalyticsEvent?.call(
-          command.name ?? BetterCommandRunnerAnalyticsEvents.invalid,
-        );
-        return;
-      }
-
-      // Checks if the command is valid (i.e. no unexpected arguments).
-      // If there are unexpected arguments this will trigger a [UsageException]
-      // which will be caught in the try catch around the super.runCommand call.
-      // Therefore, this ensures that the help event is not sent for
-      // commands that are invalid.
-      // Note that there are other scenarios that also trigger a [UsageException]
-      // so the try/catch statement can't be fully compensated for handled here.
-      var noUnexpectedArgs = topLevelResults.rest.isEmpty;
-      if (noUnexpectedArgs) {
-        _onAnalyticsEvent?.call(BetterCommandRunnerAnalyticsEvents.help);
-      }
-    }));
+    unawaited(
+      Future(() async {
+        var command = topLevelResults.command;
+        if (command != null) {
+          // Command name can only be null for top level results.
+          // But since we are taking the name of a command from the top level
+          // results there should always be a name specified.
+          assert(command.name != null, 'Command name should never be null.');
+          _onAnalyticsEvent?.call(
+            command.name ?? BetterCommandRunnerAnalyticsEvents.invalid,
+          );
+          return;
+        }
+
+        // Checks if the command is valid (i.e. no unexpected arguments).
+        // If there are unexpected arguments this will trigger a [UsageException]
+        // which will be caught in the try catch around the super.runCommand call.
+        // Therefore, this ensures that the help event is not sent for
+        // commands that are invalid.
+        // Note that there are other scenarios that also trigger a [UsageException]
+        // so the try/catch statement can't be fully compensated for handled here.
+        var noUnexpectedArgs = topLevelResults.rest.isEmpty;
+        if (noUnexpectedArgs) {
+          _onAnalyticsEvent?.call(BetterCommandRunnerAnalyticsEvents.help);
+        }
+      }),
+    );
 
     await _onBeforeRunCommand?.call(this);
 
diff --git a/lib/src/logger/helpers/progress.dart b/lib/src/logger/helpers/progress.dart
index 8b5a4f5..0dd14c0 100644
--- a/lib/src/logger/helpers/progress.dart
+++ b/lib/src/logger/helpers/progress.dart
@@ -48,7 +48,7 @@ class ProgressAnimation {
     '⠦',
     '⠧',
     '⠇',
-    '⠏'
+    '⠏',
   ];
 
   /// The list of animation frames.
@@ -64,8 +64,8 @@ class Progress {
     this._message,
     this._stdout, {
     ProgressOptions options = const ProgressOptions(),
-  })  : _stopwatch = Stopwatch(),
-        _options = options {
+  }) : _stopwatch = Stopwatch(),
+       _options = options {
     _stopwatch
       ..reset()
       ..start();
@@ -121,7 +121,8 @@ class Progress {
   void fail([String? update]) {
     _timer?.cancel();
     _write(
-        '$_clearLine${AnsiStyle.red.wrap('✗')} ${update ?? _message} $_time\n');
+      '$_clearLine${AnsiStyle.red.wrap('✗')} ${update ?? _message} $_time\n',
+    );
     _stopwatch.stop();
   }
 
diff --git a/lib/src/logger/logger.dart b/lib/src/logger/logger.dart
index c168a3e..adda15e 100644
--- a/lib/src/logger/logger.dart
+++ b/lib/src/logger/logger.dart
@@ -13,29 +13,17 @@ abstract class Logger {
   /// Display debug [message] to the user.
   /// Commands should use this for information that is important for
   /// debugging purposes.
-  void debug(
-    String message, {
-    bool newParagraph,
-    LogType type,
-  });
+  void debug(String message, {bool newParagraph, LogType type});
 
   /// Display a normal [message] to the user.
   /// Command should use this as the standard communication channel for
   /// success, progress or information messages.
-  void info(
-    String message, {
-    bool newParagraph,
-    LogType type,
-  });
+  void info(String message, {bool newParagraph, LogType type});
 
   /// Display a warning [message] to the user.
   /// Commands should use this if they have important but not critical
   /// information for the user.
-  void warning(
-    String message, {
-    bool newParagraph,
-    LogType type,
-  });
+  void warning(String message, {bool newParagraph, LogType type});
 
   /// Display an error [message] to the user.
   /// Commands should use this if they want to inform a user that an error
@@ -86,15 +74,7 @@ enum LogLevel {
   final String name;
 }
 
-enum TextLogStyle {
-  init,
-  normal,
-  hint,
-  header,
-  bullet,
-  command,
-  success,
-}
+enum TextLogStyle { init, normal, hint, header, bullet, command, success }
 
 abstract class LogType {
   const LogType();
@@ -110,10 +90,7 @@ class RawLogType extends LogType {
 /// If [title] is set the box will have a title row.
 class BoxLogType extends LogType {
   final String? title;
-  const BoxLogType({
-    this.title,
-    bool newParagraph = true,
-  });
+  const BoxLogType({this.title, bool newParagraph = true});
 }
 
 /// Abstract style console formatting.
diff --git a/lib/src/logger/loggers/std_out_logger.dart b/lib/src/logger/loggers/std_out_logger.dart
index 0ea4532..e6fee1f 100644
--- a/lib/src/logger/loggers/std_out_logger.dart
+++ b/lib/src/logger/loggers/std_out_logger.dart
@@ -17,7 +17,7 @@ class StdOutLogger extends Logger {
   final Map<String, String>? _replacements;
 
   StdOutLogger(super.logLevel, {Map<String, String>? replacements})
-      : _replacements = replacements;
+    : _replacements = replacements;
 
   @override
   int? get wrapTextColumn => stdout.hasTerminal ? stdout.terminalColumns : null;
@@ -36,13 +36,7 @@ class StdOutLogger extends Logger {
         type,
       );
     } else {
-      _log(
-        message,
-        LogLevel.debug,
-        newParagraph,
-        type,
-        prefix: 'DEBUG: ',
-      );
+      _log(message, LogLevel.debug, newParagraph, type, prefix: 'DEBUG: ');
     }
   }
 
@@ -69,13 +63,7 @@ class StdOutLogger extends Logger {
         type,
       );
     } else {
-      _log(
-        message,
-        LogLevel.warning,
-        newParagraph,
-        type,
-        prefix: 'WARNING: ',
-      );
+      _log(message, LogLevel.warning, newParagraph, type, prefix: 'WARNING: ');
     }
   }
 
@@ -87,20 +75,9 @@ class StdOutLogger extends Logger {
     LogType type = TextLogType.normal,
   }) {
     if (ansiSupported) {
-      _log(
-        AnsiStyle.red.wrap(message),
-        LogLevel.error,
-        newParagraph,
-        type,
-      );
+      _log(AnsiStyle.red.wrap(message), LogLevel.error, newParagraph, type);
     } else {
-      _log(
-        message,
-        LogLevel.error,
-        newParagraph,
-        type,
-        prefix: 'ERROR: ',
-      );
+      _log(message, LogLevel.error, newParagraph, type, prefix: 'ERROR: ');
     }
 
     if (stackTrace != null) {
@@ -128,12 +105,7 @@ class StdOutLogger extends Logger {
     // Write an empty line before the progress message if a new paragraph is
     // requested.
     if (newParagraph) {
-      write(
-        '',
-        LogLevel.info,
-        newParagraph: false,
-        newLine: true,
-      );
+      write('', LogLevel.info, newParagraph: false, newLine: true);
     }
 
     var progress = Progress(message, stdout);
@@ -217,9 +189,9 @@ class StdOutLogger extends Logger {
     message = switch (_replacements) {
       null => message,
       Map<String, String> replacements => replacements.entries.fold(
-          message,
-          (String acc, entry) => acc.replaceAll(entry.key, entry.value),
-        ),
+        message,
+        (String acc, entry) => acc.replaceAll(entry.key, entry.value),
+      ),
     };
 
     _stopAnimationInProgress();
@@ -295,8 +267,9 @@ String _formatAsBox({
   var maxTextWidthPerLine = wrapColumn - kEdges - kPaddingLeftRight * 2;
   var lines = _wrapText(message, maxTextWidthPerLine).split('\n');
   var lineWidth = lines.map((String line) => line.length).toList();
-  var maxColumnSize =
-      lineWidth.reduce((int currLen, int maxLen) => math.max(currLen, maxLen));
+  var maxColumnSize = lineWidth.reduce(
+    (int currLen, int maxLen) => math.max(currLen, maxLen),
+  );
   var textWidth = math.min(maxColumnSize, maxTextWidthPerLine);
   var textWithPaddingWidth = textWidth + kPaddingLeftRight * 2;
 
diff --git a/lib/src/package_version/package_version.dart b/lib/src/package_version/package_version.dart
index 0f0a9b1..7370f7f 100644
--- a/lib/src/package_version/package_version.dart
+++ b/lib/src/package_version/package_version.dart
@@ -20,7 +20,7 @@ abstract class PackageVersion {
   /// attempting to fetch the latest version again.
   static Future<Version?> fetchLatestPackageVersion({
     required Future<void> Function(PackageVersionData versionArtefact)
-        storePackageVersionData,
+    storePackageVersionData,
     required Future<PackageVersionData?> Function() loadPackageVersionData,
     required Future<Version?> Function() fetchLatestPackageVersion,
   }) async {
@@ -47,7 +47,7 @@ abstract class PackageVersion {
   static Future<void> _storePubDevVersion(
     Version? version, {
     required Future<void> Function(PackageVersionData versionArtefact)
-        storePackageVersionData,
+    storePackageVersionData,
   }) async {
     PackageVersionData versionArtefact;
     if (version != null) {
@@ -81,7 +81,7 @@ class PackageVersionData {
       );
 
   Map<String, dynamic> toJson() => {
-        'version': version.toString(),
-        'valid_until': validUntil.millisecondsSinceEpoch
-      };
+    'version': version.toString(),
+    'valid_until': validUntil.millisecondsSinceEpoch,
+  };
 }
diff --git a/lib/src/package_version/pub_api_client.dart b/lib/src/package_version/pub_api_client.dart
index 8e947f4..0169556 100644
--- a/lib/src/package_version/pub_api_client.dart
+++ b/lib/src/package_version/pub_api_client.dart
@@ -13,8 +13,8 @@ class PubApiClient {
   PubApiClient({
     http.Client? httpClient,
     requestTimeout = const Duration(seconds: 2),
-  })  : _pubClient = PubClient(client: httpClient),
-        _requestTimeout = requestTimeout;
+  }) : _pubClient = PubClient(client: httpClient),
+       _requestTimeout = requestTimeout;
 
   /// Tries to fetch the latest stable version, version does not include '-' or '+',
   /// for the package named [packageName].
diff --git a/lib/src/prompts/confirm.dart b/lib/src/prompts/confirm.dart
index 69cb487..7c7c4cb 100644
--- a/lib/src/prompts/confirm.dart
+++ b/lib/src/prompts/confirm.dart
@@ -10,9 +10,10 @@ Future<bool> confirm(
   bool? defaultValue,
   required Logger logger,
 }) async {
-  var prompt = defaultValue == null
-      ? '[y/n]'
-      : defaultValue
+  var prompt =
+      defaultValue == null
+          ? '[y/n]'
+          : defaultValue
           ? '[Y/n]'
           : '[y/N]';
 
diff --git a/lib/src/prompts/select.dart b/lib/src/prompts/select.dart
index ef622e6..4f955b9 100644
--- a/lib/src/prompts/select.dart
+++ b/lib/src/prompts/select.dart
@@ -22,8 +22,7 @@ Future<Option> select(
     prompt,
     options: options,
     logger: logger,
-  ))
-      .first;
+  )).first;
 }
 
 /// Prompts the user to select multiple options from a list of [options].
@@ -58,11 +57,7 @@ Future<List<Option>> _interactiveSelect(
     multiple: multiple,
   );
 
-  _renderState(
-    state: state,
-    logger: logger,
-    promptMessage: message,
-  );
+  _renderState(state: state, logger: logger, promptMessage: message);
 
   var originalEchoMode = stdin.echoMode;
   var originalLineMode = stdin.lineMode;
@@ -114,11 +109,7 @@ void _renderState({
 }) {
   _clearTerminal();
 
-  logger.write(
-    promptMessage,
-    LogLevel.info,
-    newLine: true,
-  );
+  logger.write(promptMessage, LogLevel.info, newLine: true);
 
   for (int i = 0; i < state.options.length; i++) {
     var radioButton = state.currentOrContains(i) ? '(●)' : '(○)';
@@ -173,12 +164,14 @@ class _SelectState {
 
   _SelectState toggleCurrent() {
     return _SelectState(
-        options: options,
-        selectedIndex: selectedIndex,
-        selectedOptions: selectedOptions.contains(selectedIndex)
-            ? (selectedOptions..remove(selectedIndex))
-            : (selectedOptions..add(selectedIndex)),
-        multiple: multiple);
+      options: options,
+      selectedIndex: selectedIndex,
+      selectedOptions:
+          selectedOptions.contains(selectedIndex)
+              ? (selectedOptions..remove(selectedIndex))
+              : (selectedOptions..add(selectedIndex)),
+      multiple: multiple,
+    );
   }
 
   bool currentOrContains(int index) {
@@ -214,11 +207,8 @@ void _clearTerminal() {
 // See https://en.wikipedia.org/wiki/ANSI_escape_code for further info.
 const _underlineSelectGraphicRenditionControlSequence = '\x1B[4m';
 const _resetSelectGraphicRenditionControlSequence = '\x1B[0m';
-String underline(
-  String text,
-) =>
-    [
-      _underlineSelectGraphicRenditionControlSequence,
-      text,
-      _resetSelectGraphicRenditionControlSequence
-    ].join('');
+String underline(String text) => [
+  _underlineSelectGraphicRenditionControlSequence,
+  text,
+  _resetSelectGraphicRenditionControlSequence,
+].join('');
diff --git a/test/better_command_runner/analytics_test.dart b/test/better_command_runner/analytics_test.dart
index f479e57..bfd5125 100644
--- a/test/better_command_runner/analytics_test.dart
+++ b/test/better_command_runner/analytics_test.dart
@@ -65,10 +65,12 @@ void main() {
       expect(runner.analyticsEnabled(), isFalse);
     });
 
-    test('when checking available flags then analytics flag is not present.',
-        () {
-      expect(runner.argParser.options.keys, isNot(contains('analytics')));
-    });
+    test(
+      'when checking available flags then analytics flag is not present.',
+      () {
+        expect(runner.argParser.options.keys, isNot(contains('analytics')));
+      },
+    );
   });
 
   group('Given runner with onAnalyticsEvent callback defined', () {
@@ -103,89 +105,100 @@ void main() {
     });
 
     test(
-        'when running command with no-analytics flag then analytics is disabled.',
-        () async {
-      var args = ['--no-${BetterCommandRunnerFlags.analytics}'];
-      await runner.run(args);
+      'when running command with no-analytics flag then analytics is disabled.',
+      () async {
+        var args = ['--no-${BetterCommandRunnerFlags.analytics}'];
+        await runner.run(args);
 
-      await flushEventQueue();
+        await flushEventQueue();
 
-      expect(runner.analyticsEnabled(), isFalse);
-    });
+        expect(runner.analyticsEnabled(), isFalse);
+      },
+    );
 
-    test('when running invalid command then "invalid" analytics event is sent.',
-        () async {
-      var args = ['this could be a command argument'];
+    test(
+      'when running invalid command then "invalid" analytics event is sent.',
+      () async {
+        var args = ['this could be a command argument'];
 
-      try {
-        await runner.run(args);
-      } catch (_) {
-        // Ignore any exception
-      }
+        try {
+          await runner.run(args);
+        } catch (_) {
+          // Ignore any exception
+        }
 
-      await flushEventQueue();
+        await flushEventQueue();
 
-      expect(events, hasLength(1));
-      expect(events.first, equals('invalid'));
-    });
+        expect(events, hasLength(1));
+        expect(events.first, equals('invalid'));
+      },
+    );
 
     test(
-        'when running with unknown command then "invalid" analytics event is sent.',
-        () async {
-      var args = ['--unknown-command'];
+      'when running with unknown command then "invalid" analytics event is sent.',
+      () async {
+        var args = ['--unknown-command'];
 
-      try {
-        await runner.run(args);
-      } catch (_) {
-        // Ignore any exception
-      }
+        try {
+          await runner.run(args);
+        } catch (_) {
+          // Ignore any exception
+        }
 
-      await flushEventQueue();
+        await flushEventQueue();
 
-      expect(events, hasLength(1));
-      expect(events.first, equals('invalid'));
-    });
+        expect(events, hasLength(1));
+        expect(events.first, equals('invalid'));
+      },
+    );
 
-    test('when running with no command then "help" analytics event is sent.',
-        () async {
-      await runner.run([]);
+    test(
+      'when running with no command then "help" analytics event is sent.',
+      () async {
+        await runner.run([]);
 
-      await flushEventQueue();
+        await flushEventQueue();
 
-      expect(events, hasLength(1));
-      expect(events.first, equals('help'));
-    });
+        expect(events, hasLength(1));
+        expect(events.first, equals('help'));
+      },
+    );
 
     test(
-        'when running with only registered flag then "help" analytics event is sent.',
-        () async {
-      await runner.run(['--${BetterCommandRunnerFlags.analytics}']);
+      'when running with only registered flag then "help" analytics event is sent.',
+      () async {
+        await runner.run(['--${BetterCommandRunnerFlags.analytics}']);
 
-      await flushEventQueue();
+        await flushEventQueue();
 
-      expect(events, hasLength(1));
-      expect(events.first, equals('help'));
-    });
+        expect(events, hasLength(1));
+        expect(events.first, equals('help'));
+      },
+    );
 
-    test('when running with help command then "help" analytics event is sent.',
-        () async {
-      await runner.run(['help']);
+    test(
+      'when running with help command then "help" analytics event is sent.',
+      () async {
+        await runner.run(['help']);
 
-      await flushEventQueue();
+        await flushEventQueue();
 
-      expect(events, hasLength(1));
-      expect(events.first, equals('help'));
-    });
+        expect(events, hasLength(1));
+        expect(events.first, equals('help'));
+      },
+    );
 
-    test('when running with help flag then "help" analytics event is sent.',
-        () async {
-      await runner.run(['--help']);
+    test(
+      'when running with help flag then "help" analytics event is sent.',
+      () async {
+        await runner.run(['--help']);
 
-      await flushEventQueue();
+        await flushEventQueue();
 
-      expect(events, hasLength(1));
-      expect(events.first, equals('help'));
-    });
+        expect(events, hasLength(1));
+        expect(events.first, equals('help'));
+      },
+    );
   });
 
   group('Given runner with registered command and analytics enabled', () {
@@ -203,47 +216,51 @@ void main() {
       events = [];
     });
 
-    test('when running with registered command then command name is sent,',
-        () async {
-      var args = [MockCommand.commandName];
+    test(
+      'when running with registered command then command name is sent,',
+      () async {
+        var args = [MockCommand.commandName];
 
-      await runner.run(args);
+        await runner.run(args);
 
-      await flushEventQueue();
+        await flushEventQueue();
 
-      expect(events, hasLength(1));
-      expect(events.first, equals(MockCommand.commandName));
-    });
+        expect(events, hasLength(1));
+        expect(events.first, equals(MockCommand.commandName));
+      },
+    );
 
     test(
-        'when running with registered command and option then command name is sent,',
-        () async {
-      var args = [MockCommand.commandName, '--name', 'serverpod'];
+      'when running with registered command and option then command name is sent,',
+      () async {
+        var args = [MockCommand.commandName, '--name', 'serverpod'];
 
-      await runner.run(args);
+        await runner.run(args);
 
-      await flushEventQueue();
+        await flushEventQueue();
 
-      expect(events, hasLength(1));
-      expect(events.first, equals(MockCommand.commandName));
-    });
+        expect(events, hasLength(1));
+        expect(events.first, equals(MockCommand.commandName));
+      },
+    );
 
     test(
-        'when running with registered command but invalid option then "invalid" analytics event is sent,',
-        () async {
-      var args = [MockCommand.commandName, '--name', 'invalid'];
+      'when running with registered command but invalid option then "invalid" analytics event is sent,',
+      () async {
+        var args = [MockCommand.commandName, '--name', 'invalid'];
 
-      try {
-        await runner.run(args);
-      } catch (_) {
-        // Ignore any exception
-      }
+        try {
+          await runner.run(args);
+        } catch (_) {
+          // Ignore any exception
+        }
 
-      await flushEventQueue();
+        await flushEventQueue();
 
-      expect(events, hasLength(1));
-      expect(events.first, equals('invalid'));
-    });
+        expect(events, hasLength(1));
+        expect(events.first, equals('invalid'));
+      },
+    );
   });
 
   group('Given runner with registered command and analytics enabled', () {
@@ -264,50 +281,55 @@ void main() {
     });
 
     test(
-        'when running with registered command that hangs then command name is sent',
-        () async {
-      var args = [CompletableMockCommand.commandName];
+      'when running with registered command that hangs then command name is sent',
+      () async {
+        var args = [CompletableMockCommand.commandName];
 
-      unawaited(runner.run(args));
+        unawaited(runner.run(args));
 
-      await flushEventQueue();
+        await flushEventQueue();
 
-      expect(events, hasLength(1));
-      expect(events.first, equals(CompletableMockCommand.commandName));
+        expect(events, hasLength(1));
+        expect(events.first, equals(CompletableMockCommand.commandName));
 
-      command.completer.complete();
-    });
+        command.completer.complete();
+      },
+    );
 
     test(
-        'when running with registered command that hangs and option then command name is sent,',
-        () async {
-      var args = [CompletableMockCommand.commandName, '--name', 'serverpod'];
+      'when running with registered command that hangs and option then command name is sent,',
+      () async {
+        var args = [CompletableMockCommand.commandName, '--name', 'serverpod'];
 
-      unawaited(runner.run(args));
+        unawaited(runner.run(args));
 
-      await flushEventQueue();
+        await flushEventQueue();
 
-      expect(events, hasLength(1));
-      expect(events.first, equals(CompletableMockCommand.commandName));
+        expect(events, hasLength(1));
+        expect(events.first, equals(CompletableMockCommand.commandName));
 
-      command.completer.complete();
-    });
+        command.completer.complete();
+      },
+    );
 
     test(
-        'when running with registered command that hangs but invalid option then "invalid" analytics event is sent,',
-        () async {
-      var args = [CompletableMockCommand.commandName, '--name', 'invalid'];
+      'when running with registered command that hangs but invalid option then "invalid" analytics event is sent,',
+      () async {
+        var args = [CompletableMockCommand.commandName, '--name', 'invalid'];
 
-      unawaited(runner.run(args).catchError((_) {
-        // Ignore parse error
-      }));
+        unawaited(
+          runner.run(args).catchError((_) {
+            // Ignore parse error
+          }),
+        );
 
-      await flushEventQueue();
+        await flushEventQueue();
 
-      expect(events, hasLength(1));
-      expect(events.first, equals('invalid'));
+        expect(events, hasLength(1));
+        expect(events.first, equals('invalid'));
 
-      command.completer.complete();
-    });
+        command.completer.complete();
+      },
+    );
   });
 }
diff --git a/test/better_command_runner/command_test.dart b/test/better_command_runner/command_test.dart
index 9cf1630..26d72e8 100644
--- a/test/better_command_runner/command_test.dart
+++ b/test/better_command_runner/command_test.dart
@@ -38,16 +38,14 @@ void main() {
   group('Given runner with registered command', () {
     setUp(() {
       mockCommand = MockCommand();
-      runner = BetterCommandRunner(
-        'test',
-        'this is a test cli',
-      )..addCommand(mockCommand);
+      runner = BetterCommandRunner('test', 'this is a test cli')
+        ..addCommand(mockCommand);
     });
 
     group('when running registered command with global flag', () {
       var args = [
         '--${BetterCommandRunnerFlags.quiet}',
-        MockCommand.commandName
+        MockCommand.commandName,
       ];
       setUp(() async => await runner.run(args));
 
@@ -85,33 +83,35 @@ void main() {
     });
 
     test(
-        'when running registered command with invalid option then command is never run.',
-        () async {
-      var args = [MockCommand.commandName, '--name', 'invalid'];
-
-      try {
-        await runner.run(args);
-      } catch (_) {
-        // ignore any exceptions.
-      }
-      expect(mockCommand.numberOfRuns, equals(0));
-    });
+      'when running registered command with invalid option then command is never run.',
+      () async {
+        var args = [MockCommand.commandName, '--name', 'invalid'];
+
+        try {
+          await runner.run(args);
+        } catch (_) {
+          // ignore any exceptions.
+        }
+        expect(mockCommand.numberOfRuns, equals(0));
+      },
+    );
   });
 
   test(
-      'Given runner with registered command and onBeforeRunCommand callback then onBeforeRunCommand is called before running command',
-      () async {
-    List<String> calls = [];
-    mockCommand = MockCommand(onRun: () => calls.add('command'));
-    runner = BetterCommandRunner(
-      'test',
-      'this is a test cli',
-      onBeforeRunCommand: (_) => Future(() => calls.add('callback')),
-    )..addCommand(mockCommand);
-
-    var args = [MockCommand.commandName];
-
-    await runner.run(args);
-    expect(calls, equals(['callback', 'command']));
-  });
+    'Given runner with registered command and onBeforeRunCommand callback then onBeforeRunCommand is called before running command',
+    () async {
+      List<String> calls = [];
+      mockCommand = MockCommand(onRun: () => calls.add('command'));
+      runner = BetterCommandRunner(
+        'test',
+        'this is a test cli',
+        onBeforeRunCommand: (_) => Future(() => calls.add('callback')),
+      )..addCommand(mockCommand);
+
+      var args = [MockCommand.commandName];
+
+      await runner.run(args);
+      expect(calls, equals(['callback', 'command']));
+    },
+  );
 }
diff --git a/test/better_command_runner/default_flags_test.dart b/test/better_command_runner/default_flags_test.dart
index d4bb0d3..c2d715e 100644
--- a/test/better_command_runner/default_flags_test.dart
+++ b/test/better_command_runner/default_flags_test.dart
@@ -9,16 +9,18 @@ void main() {
       onAnalyticsEvent: (event) {},
     );
 
-    test('when run with --verbose flag then runner completes successfully.',
-        () async {
-      var args = ['--verbose'];
-      await expectLater(
-        runner.run(args),
-        completes,
-        reason:
-            'Expected runner to successfully parse and complete when run with --verbose flag.',
-      );
-    });
+    test(
+      'when run with --verbose flag then runner completes successfully.',
+      () async {
+        var args = ['--verbose'];
+        await expectLater(
+          runner.run(args),
+          completes,
+          reason:
+              'Expected runner to successfully parse and complete when run with --verbose flag.',
+        );
+      },
+    );
 
     test('when run with -v flag then runner completes successfully.', () async {
       var args = ['-v'];
@@ -30,16 +32,18 @@ void main() {
       );
     });
 
-    test('when run with --quiet flag then runner completes successfully.',
-        () async {
-      var args = ['--quiet'];
-      await expectLater(
-        runner.run(args),
-        completes,
-        reason:
-            'Expected runner to successfully parse and complete when run with --quiet flag.',
-      );
-    });
+    test(
+      'when run with --quiet flag then runner completes successfully.',
+      () async {
+        var args = ['--quiet'];
+        await expectLater(
+          runner.run(args),
+          completes,
+          reason:
+              'Expected runner to successfully parse and complete when run with --quiet flag.',
+        );
+      },
+    );
 
     test('when run with -q flag then runner completes successfully.', () async {
       var args = ['-q'];
@@ -51,16 +55,18 @@ void main() {
       );
     });
 
-    test('when run with --analytics flag then runner completes successfully.',
-        () async {
-      var args = ['--analytics'];
-      await expectLater(
-        runner.run(args),
-        completes,
-        reason:
-            'Expected runner to successfully parse and complete when run with --analytics flag.',
-      );
-    });
+    test(
+      'when run with --analytics flag then runner completes successfully.',
+      () async {
+        var args = ['--analytics'];
+        await expectLater(
+          runner.run(args),
+          completes,
+          reason:
+              'Expected runner to successfully parse and complete when run with --analytics flag.',
+        );
+      },
+    );
 
     test('when run with -a flag then runner completes successfully.', () async {
       var args = ['-a'];
diff --git a/test/better_command_runner/exit_exceptions_test.dart b/test/better_command_runner/exit_exceptions_test.dart
index 697848d..160ca49 100644
--- a/test/better_command_runner/exit_exceptions_test.dart
+++ b/test/better_command_runner/exit_exceptions_test.dart
@@ -28,45 +28,55 @@ class MockCommand extends Command {
 
 void main() {
   group('Given runner with registered command', () {
-    var runner = BetterCommandRunner(
-      'test',
-      'this is a test cli',
-    )..addCommand(MockCommand());
+    var runner = BetterCommandRunner('test', 'this is a test cli')
+      ..addCommand(MockCommand());
 
     test(
-        'when running with unknown command then ExitException with command not found exit code is thrown.',
-        () async {
-      var args = ['unknown-command'];
+      'when running with unknown command then ExitException with command not found exit code is thrown.',
+      () async {
+        var args = ['unknown-command'];
 
-      await expectLater(
-        () => runner.run(args),
-        throwsA(predicate<ExitException>(
-            (e) => e.exitCode == BetterCommandRunner.exitCodeCommandNotFound)),
-      );
-    });
+        await expectLater(
+          () => runner.run(args),
+          throwsA(
+            predicate<ExitException>(
+              (e) => e.exitCode == BetterCommandRunner.exitCodeCommandNotFound,
+            ),
+          ),
+        );
+      },
+    );
 
     test(
-        'when running with invalid command then ExitException with command not found exit code is thrown.',
-        () async {
-      List<String> args = ['this it not a valid command'];
+      'when running with invalid command then ExitException with command not found exit code is thrown.',
+      () async {
+        List<String> args = ['this it not a valid command'];
 
-      await expectLater(
-        () => runner.run(args),
-        throwsA(predicate<ExitException>(
-            (e) => e.exitCode == BetterCommandRunner.exitCodeCommandNotFound)),
-      );
-    });
+        await expectLater(
+          () => runner.run(args),
+          throwsA(
+            predicate<ExitException>(
+              (e) => e.exitCode == BetterCommandRunner.exitCodeCommandNotFound,
+            ),
+          ),
+        );
+      },
+    );
 
     test(
-        'when running command without mandatory option then ExitException with command not found exit code is thrown.',
-        () async {
-      List<String> args = [MockCommand.commandName];
+      'when running command without mandatory option then ExitException with command not found exit code is thrown.',
+      () async {
+        List<String> args = [MockCommand.commandName];
 
-      await expectLater(
-        () => runner.run(args),
-        throwsA(predicate<ExitException>(
-            (e) => e.exitCode == BetterCommandRunner.exitCodeCommandNotFound)),
-      );
-    });
+        await expectLater(
+          () => runner.run(args),
+          throwsA(
+            predicate<ExitException>(
+              (e) => e.exitCode == BetterCommandRunner.exitCodeCommandNotFound,
+            ),
+          ),
+        );
+      },
+    );
   });
 }
diff --git a/test/better_command_runner/logging_test.dart b/test/better_command_runner/logging_test.dart
index f96aa52..6e5e360 100644
--- a/test/better_command_runner/logging_test.dart
+++ b/test/better_command_runner/logging_test.dart
@@ -86,11 +86,13 @@ void main() {
         expect(infos, hasLength(0));
       });
 
-      test('then option name is mandatory message is logged to error.',
-          () async {
-        expect(errors, hasLength(1));
-        expect(errors.first, contains('Option name is mandatory'));
-      });
+      test(
+        'then option name is mandatory message is logged to error.',
+        () async {
+          expect(errors, hasLength(1));
+          expect(errors.first, contains('Option name is mandatory'));
+        },
+      );
     });
   });
 }
diff --git a/test/better_command_runner/parse_log_level_test.dart b/test/better_command_runner/parse_log_level_test.dart
index 587c90e..90457ff 100644
--- a/test/better_command_runner/parse_log_level_test.dart
+++ b/test/better_command_runner/parse_log_level_test.dart
@@ -104,14 +104,15 @@ void main() {
     )..addCommand(MockCommand());
 
     test(
-        'when running with registered command then command name is passed to setLogLevel callback.',
-        () async {
-      var args = [MockCommand.commandName];
+      'when running with registered command then command name is passed to setLogLevel callback.',
+      () async {
+        var args = [MockCommand.commandName];
 
-      await runner.run(args);
+        await runner.run(args);
 
-      expect(parsedCommandName, MockCommand.commandName);
-    });
+        expect(parsedCommandName, MockCommand.commandName);
+      },
+    );
 
     group('when verbose flag is passed before registered command', () {
       var args = [
diff --git a/test/better_command_test.dart b/test/better_command_test.dart
index 5a67d1a..35e4678 100644
--- a/test/better_command_test.dart
+++ b/test/better_command_test.dart
@@ -25,18 +25,20 @@ class MockCommand extends BetterCommand {
 void main() {
   group('Given a better command registered in the better command runner', () {
     var infos = <String>[];
-    var betterCommand =
-        MockCommand(logInfo: (String message) => infos.add(message));
+    var betterCommand = MockCommand(
+      logInfo: (String message) => infos.add(message),
+    );
     var runner = BetterCommandRunner('test', 'test project')
       ..addCommand(betterCommand);
 
     test(
-        'when running command option --help flag then usage is printed to commands logInfo',
-        () async {
-      await runner.run([MockCommand.commandName, '--help']);
+      'when running command option --help flag then usage is printed to commands logInfo',
+      () async {
+        await runner.run([MockCommand.commandName, '--help']);
 
-      expect(infos, hasLength(1));
-      expect(infos.first, betterCommand.usage);
-    });
+        expect(infos, hasLength(1));
+        expect(infos.first, betterCommand.usage);
+      },
+    );
   });
 }
diff --git a/test/documentation_generator/generate_markdown_test.dart b/test/documentation_generator/generate_markdown_test.dart
index de7a81c..1446291 100644
--- a/test/documentation_generator/generate_markdown_test.dart
+++ b/test/documentation_generator/generate_markdown_test.dart
@@ -101,60 +101,62 @@ void main() {
       var vegetableCommandOutput = output['spice.md'];
 
       expect(
-          vegetableCommandOutput,
-          startsWith(
-            '## Usage\n'
-            '\n'
-            '```console\n'
-            'Modifies the spice mix in your dish.\n'
-            '\n'
-            'Usage: cookcli spice <subcommand> [arguments]\n'
-            '-h, --help    Print this usage information.\n'
-            '\n'
-            'Available subcommands:\n'
-            '  add      Add something to the spice mix\n'
-            '  remove   Remove something from the spice mix\n'
-            '\n'
-            'Run "cookcli help" to see global options.\n'
-            '```\n'
-            '\n',
-          ));
+        vegetableCommandOutput,
+        startsWith(
+          '## Usage\n'
+          '\n'
+          '```console\n'
+          'Modifies the spice mix in your dish.\n'
+          '\n'
+          'Usage: cookcli spice <subcommand> [arguments]\n'
+          '-h, --help    Print this usage information.\n'
+          '\n'
+          'Available subcommands:\n'
+          '  add      Add something to the spice mix\n'
+          '  remove   Remove something from the spice mix\n'
+          '\n'
+          'Run "cookcli help" to see global options.\n'
+          '```\n'
+          '\n',
+        ),
+      );
     });
 
     test('then output ends with the sub commands', () async {
       var vegetableCommandOutput = output['spice.md'];
 
       expect(
-          vegetableCommandOutput,
-          endsWith(
-            '### Sub commands\n'
-            '\n'
-            '#### `add`\n'
-            '\n'
-            '```console\n'
-            'Add something to the spice mix\n'
-            '\n'
-            'Usage: cookcli spice add [arguments]\n'
-            '-h, --help      Print this usage information.\n'
-            '    --curry     Include curry in the spice mix.\n'
-            '    --pepper    Include pepper in the spice mix.\n'
-            '\n'
-            'Run "cookcli help" to see global options.\n'
-            '```\n'
-            '\n'
-            '#### `remove`\n'
-            '\n'
-            '```console\n'
-            'Remove something from the spice mix\n'
-            '\n'
-            'Usage: cookcli spice remove [arguments]\n'
-            '-h, --help      Print this usage information.\n'
-            '    --curry     Remove curry from the spice mix.\n'
-            '    --pepper    Remove pepper from the spice mix.\n'
-            '\n'
-            'Run "cookcli help" to see global options.\n'
-            '```\n',
-          ));
+        vegetableCommandOutput,
+        endsWith(
+          '### Sub commands\n'
+          '\n'
+          '#### `add`\n'
+          '\n'
+          '```console\n'
+          'Add something to the spice mix\n'
+          '\n'
+          'Usage: cookcli spice add [arguments]\n'
+          '-h, --help      Print this usage information.\n'
+          '    --curry     Include curry in the spice mix.\n'
+          '    --pepper    Include pepper in the spice mix.\n'
+          '\n'
+          'Run "cookcli help" to see global options.\n'
+          '```\n'
+          '\n'
+          '#### `remove`\n'
+          '\n'
+          '```console\n'
+          'Remove something from the spice mix\n'
+          '\n'
+          'Usage: cookcli spice remove [arguments]\n'
+          '-h, --help      Print this usage information.\n'
+          '    --curry     Remove curry from the spice mix.\n'
+          '    --pepper    Remove pepper from the spice mix.\n'
+          '\n'
+          'Run "cookcli help" to see global options.\n'
+          '```\n',
+        ),
+      );
     });
   });
 }
diff --git a/test/local_storage_manager/local_storage_manager_test.dart b/test/local_storage_manager/local_storage_manager_test.dart
index 005cdd1..0287c2a 100644
--- a/test/local_storage_manager/local_storage_manager_test.dart
+++ b/test/local_storage_manager/local_storage_manager_test.dart
@@ -12,8 +12,7 @@ void main() {
     tempDir.listSync().forEach((file) => file.deleteSync());
   });
 
-  test(
-      'Given an existing file '
+  test('Given an existing file '
       'when calling removeFile '
       'then the file is deleted successfully', () async {
     var fileName = 'test.json';
@@ -28,8 +27,7 @@ void main() {
     expect(file.existsSync(), isFalse);
   });
 
-  test(
-      'Given a non-existing file '
+  test('Given a non-existing file '
       'when calling removeFile '
       'then no exception is thrown', () async {
     var fileName = 'nonexistent.json';
@@ -43,8 +41,7 @@ void main() {
     );
   });
 
-  test(
-      'Given a valid json object '
+  test('Given a valid json object '
       'when calling storeJsonFile '
       'then the file is created with correct content', () async {
     var fileName = 'test.json';
@@ -61,8 +58,7 @@ void main() {
     expect(file.readAsStringSync(), '{\n  "key": "value"\n}');
   });
 
-  test(
-      'Given a json object with non compatible values '
+  test('Given a json object with non compatible values '
       'when calling storeJsonFile '
       'then it throws SerializationException', () async {
     var fileName = 'test.json';
@@ -78,8 +74,7 @@ void main() {
     );
   });
 
-  test(
-      'Given an existing json file '
+  test('Given an existing json file '
       'when calling tryFetchAndDeserializeJsonFile '
       'then it returns the deserialized object', () async {
     var fileName = 'test.json';
@@ -88,7 +83,8 @@ void main() {
     file.writeAsStringSync(fileContent);
 
     var result = await LocalStorageManager.tryFetchAndDeserializeJsonFile<
-        Map<String, dynamic>>(
+      Map<String, dynamic>
+    >(
       fileName: fileName,
       localStoragePath: localStoragePath,
       fromJson: (json) => json,
@@ -97,14 +93,14 @@ void main() {
     expect(result, {'key': 'value'});
   });
 
-  test(
-      'Given a missing json file '
+  test('Given a missing json file '
       'when calling tryFetchAndDeserializeJsonFile '
       'then it returns null', () async {
     var fileName = 'nonexistent.json';
 
     var result = await LocalStorageManager.tryFetchAndDeserializeJsonFile<
-        Map<String, dynamic>>(
+      Map<String, dynamic>
+    >(
       fileName: fileName,
       localStoragePath: localStoragePath,
       fromJson: (json) => json,
@@ -113,8 +109,7 @@ void main() {
     expect(result, isNull);
   });
 
-  test(
-      'Given a malformed json file '
+  test('Given a malformed json file '
       'when calling tryFetchAndDeserializeJsonFile '
       'then it throws DeserializationException', () async {
     var fileName = 'invalid.json';
@@ -124,7 +119,8 @@ void main() {
 
     expect(
       () => LocalStorageManager.tryFetchAndDeserializeJsonFile<
-          Map<String, dynamic>>(
+        Map<String, dynamic>
+      >(
         fileName: fileName,
         localStoragePath: localStoragePath,
         fromJson: (json) => json,
@@ -133,8 +129,7 @@ void main() {
     );
   });
 
-  test(
-      'Given a corrupt file '
+  test('Given a corrupt file '
       'when calling tryFetchAndDeserializeJsonFile '
       'then it throws ReadException', () async {
     var fileName = 'invalid.json';
@@ -143,7 +138,8 @@ void main() {
 
     expect(
       () => LocalStorageManager.tryFetchAndDeserializeJsonFile<
-          Map<String, dynamic>>(
+        Map<String, dynamic>
+      >(
         fileName: fileName,
         localStoragePath: localStoragePath,
         fromJson: (json) => json,
diff --git a/test/package_version_test.dart b/test/package_version_test.dart
index 18038a8..dd40c2e 100644
--- a/test/package_version_test.dart
+++ b/test/package_version_test.dart
@@ -7,58 +7,61 @@ void main() {
 
   group('Given version is returned from load', () {
     test(
-        'when fetched with "valid until" time in the future then version is returned.',
-        () async {
-      var packageVersionData = PackageVersionData(
-        versionForTest,
-        DateTime.now().add(const Duration(hours: 1)),
-      );
-
-      var fetchedVersion = await PackageVersion.fetchLatestPackageVersion(
-        storePackageVersionData: (PackageVersionData _) async => (),
-        loadPackageVersionData: () async => packageVersionData,
-        fetchLatestPackageVersion: () async => null,
-      );
-
-      expect(fetchedVersion, isNotNull);
-      expect(fetchedVersion, versionForTest);
-    });
-
-    group('with "valid until" already passed', () {
-      test(
-          'when successful in fetching latest version from fetch then new version is stored and returned.',
-          () async {
-        PackageVersionData? storedPackageVersion;
-        PackageVersionData packageVersionData = PackageVersionData(
+      'when fetched with "valid until" time in the future then version is returned.',
+      () async {
+        var packageVersionData = PackageVersionData(
           versionForTest,
-          DateTime.now().subtract(
-            const Duration(hours: 1),
-          ),
+          DateTime.now().add(const Duration(hours: 1)),
         );
-        var pubDevVersion = versionForTest.nextMajor;
 
         var fetchedVersion = await PackageVersion.fetchLatestPackageVersion(
-          storePackageVersionData:
-              (PackageVersionData versionDataToStore) async =>
-                  (storedPackageVersion = versionDataToStore),
+          storePackageVersionData: (PackageVersionData _) async => (),
           loadPackageVersionData: () async => packageVersionData,
-          fetchLatestPackageVersion: () async => pubDevVersion,
+          fetchLatestPackageVersion: () async => null,
         );
 
         expect(fetchedVersion, isNotNull);
-        expect(fetchedVersion, pubDevVersion);
-        expect(storedPackageVersion, isNotNull);
-        expect(storedPackageVersion?.version, pubDevVersion);
-        var timeDifferent = storedPackageVersion?.validUntil.difference(
-            DateTime.now()
-                .add(PackageVersionConstants.localStorageValidityTime));
-        expect(
-          timeDifferent,
-          lessThan(const Duration(minutes: 1)),
-          reason: 'Successfully stored version should have a valid until time '
-              'close to the current time plus the validity time.',
-        );
-      });
+        expect(fetchedVersion, versionForTest);
+      },
+    );
+
+    group('with "valid until" already passed', () {
+      test(
+        'when successful in fetching latest version from fetch then new version is stored and returned.',
+        () async {
+          PackageVersionData? storedPackageVersion;
+          PackageVersionData packageVersionData = PackageVersionData(
+            versionForTest,
+            DateTime.now().subtract(const Duration(hours: 1)),
+          );
+          var pubDevVersion = versionForTest.nextMajor;
+
+          var fetchedVersion = await PackageVersion.fetchLatestPackageVersion(
+            storePackageVersionData:
+                (PackageVersionData versionDataToStore) async =>
+                    (storedPackageVersion = versionDataToStore),
+            loadPackageVersionData: () async => packageVersionData,
+            fetchLatestPackageVersion: () async => pubDevVersion,
+          );
+
+          expect(fetchedVersion, isNotNull);
+          expect(fetchedVersion, pubDevVersion);
+          expect(storedPackageVersion, isNotNull);
+          expect(storedPackageVersion?.version, pubDevVersion);
+          var timeDifferent = storedPackageVersion?.validUntil.difference(
+            DateTime.now().add(
+              PackageVersionConstants.localStorageValidityTime,
+            ),
+          );
+          expect(
+            timeDifferent,
+            lessThan(const Duration(minutes: 1)),
+            reason:
+                'Successfully stored version should have a valid until time '
+                'close to the current time plus the validity time.',
+          );
+        },
+      );
 
       test('when failing to fetch latest then null is returned.', () async {
         PackageVersionData? storedPackageVersion;
@@ -73,12 +76,13 @@ void main() {
         expect(version, isNull);
         expect(storedPackageVersion, isNotNull);
         var timeDifferent = storedPackageVersion?.validUntil.difference(
-            DateTime.now()
-                .add(PackageVersionConstants.badConnectionRetryTimeout));
+          DateTime.now().add(PackageVersionConstants.badConnectionRetryTimeout),
+        );
         expect(
           timeDifferent,
           lessThan(const Duration(minutes: 1)),
-          reason: 'Failed fetch stored version should have a valid until time '
+          reason:
+              'Failed fetch stored version should have a valid until time '
               'close to the current time plus the bad connection retry timeout.',
         );
       });
@@ -87,54 +91,59 @@ void main() {
 
   group('Given no version is returned from load', () {
     test(
-        'when successful in fetching latest version then version is stored and returned.',
-        () async {
-      PackageVersionData? storedPackageVersion;
-      var version = await PackageVersion.fetchLatestPackageVersion(
-        storePackageVersionData:
-            (PackageVersionData packageVersionData) async =>
-                (storedPackageVersion = packageVersionData),
-        loadPackageVersionData: () async => null,
-        fetchLatestPackageVersion: () async => versionForTest,
-      );
+      'when successful in fetching latest version then version is stored and returned.',
+      () async {
+        PackageVersionData? storedPackageVersion;
+        var version = await PackageVersion.fetchLatestPackageVersion(
+          storePackageVersionData:
+              (PackageVersionData packageVersionData) async =>
+                  (storedPackageVersion = packageVersionData),
+          loadPackageVersionData: () async => null,
+          fetchLatestPackageVersion: () async => versionForTest,
+        );
 
-      expect(version, isNotNull);
-      expect(version, versionForTest);
-      expect(storedPackageVersion, isNotNull);
-      expect(storedPackageVersion?.version, versionForTest);
-      var timeDifferent = storedPackageVersion?.validUntil.difference(
-          DateTime.now().add(PackageVersionConstants.localStorageValidityTime));
-      expect(
-        timeDifferent,
-        lessThan(const Duration(minutes: 1)),
-        reason: 'Successfully stored version should have a valid until time '
-            'close to the current time plus the validity time.',
-      );
-    });
+        expect(version, isNotNull);
+        expect(version, versionForTest);
+        expect(storedPackageVersion, isNotNull);
+        expect(storedPackageVersion?.version, versionForTest);
+        var timeDifferent = storedPackageVersion?.validUntil.difference(
+          DateTime.now().add(PackageVersionConstants.localStorageValidityTime),
+        );
+        expect(
+          timeDifferent,
+          lessThan(const Duration(minutes: 1)),
+          reason:
+              'Successfully stored version should have a valid until time '
+              'close to the current time plus the validity time.',
+        );
+      },
+    );
 
     test(
-        'when failing to fetch latest then timeout is stored and null is returned.',
-        () async {
-      PackageVersionData? storedPackageVersion;
-      var version = await PackageVersion.fetchLatestPackageVersion(
-        storePackageVersionData:
-            (PackageVersionData packageVersionData) async =>
-                (storedPackageVersion = packageVersionData),
-        loadPackageVersionData: () async => null,
-        fetchLatestPackageVersion: () async => null,
-      );
+      'when failing to fetch latest then timeout is stored and null is returned.',
+      () async {
+        PackageVersionData? storedPackageVersion;
+        var version = await PackageVersion.fetchLatestPackageVersion(
+          storePackageVersionData:
+              (PackageVersionData packageVersionData) async =>
+                  (storedPackageVersion = packageVersionData),
+          loadPackageVersionData: () async => null,
+          fetchLatestPackageVersion: () async => null,
+        );
 
-      expect(version, isNull);
-      expect(storedPackageVersion, isNotNull);
-      var timeDifferent = storedPackageVersion?.validUntil.difference(
-          DateTime.now()
-              .add(PackageVersionConstants.badConnectionRetryTimeout));
-      expect(
-        timeDifferent,
-        lessThan(const Duration(minutes: 1)),
-        reason: 'Failed fetch stored version should have a valid until time '
-            'close to the current time plus the bad connection retry timeout.',
-      );
-    });
+        expect(version, isNull);
+        expect(storedPackageVersion, isNotNull);
+        var timeDifferent = storedPackageVersion?.validUntil.difference(
+          DateTime.now().add(PackageVersionConstants.badConnectionRetryTimeout),
+        );
+        expect(
+          timeDifferent,
+          lessThan(const Duration(minutes: 1)),
+          reason:
+              'Failed fetch stored version should have a valid until time '
+              'close to the current time plus the bad connection retry timeout.',
+        );
+      },
+    );
   });
 }
diff --git a/test/prompts/confirm_test.dart b/test/prompts/confirm_test.dart
index bc3f4a8..7f1de0e 100644
--- a/test/prompts/confirm_test.dart
+++ b/test/prompts/confirm_test.dart
@@ -6,144 +6,80 @@ import '../test_utils/io_helper.dart';
 void main() {
   var logger = StdOutLogger(LogLevel.debug);
 
-  test(
-      'Given confirm prompt '
+  test('Given confirm prompt '
       'when providing valid input "yes" '
       'then should return true', () async {
     late Future<bool> result;
-    await collectOutput(
-      stdinLines: ['yes'],
-      () {
-        result = confirm(
-          'Are you sure?',
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(stdinLines: ['yes'], () {
+      result = confirm('Are you sure?', logger: logger);
+    });
 
-    await expectLater(
-      result,
-      completion(isTrue),
-    );
+    await expectLater(result, completion(isTrue));
   });
 
-  test(
-      'Given confirm prompt '
+  test('Given confirm prompt '
       'when providing valid input "y" '
       'then should return true', () async {
     late Future<bool> result;
-    await collectOutput(
-      stdinLines: ['y'],
-      () {
-        result = confirm(
-          'Are you sure?',
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(stdinLines: ['y'], () {
+      result = confirm('Are you sure?', logger: logger);
+    });
 
-    await expectLater(
-      result,
-      completion(isTrue),
-    );
+    await expectLater(result, completion(isTrue));
   });
 
-  test(
-      'Given confirm prompt '
+  test('Given confirm prompt '
       'when providing valid input capital "Y" '
       'then should return true', () async {
     late Future<bool> result;
-    await collectOutput(
-      stdinLines: ['Y'],
-      () {
-        result = confirm(
-          'Are you sure?',
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(stdinLines: ['Y'], () {
+      result = confirm('Are you sure?', logger: logger);
+    });
 
-    await expectLater(
-      result,
-      completion(isTrue),
-    );
+    await expectLater(result, completion(isTrue));
   });
 
-  test(
-      'Given confirm prompt '
+  test('Given confirm prompt '
       'when providing valid input "no" '
       'then should return false', () async {
     late Future<bool> result;
-    await collectOutput(
-      stdinLines: ['no'],
-      () async {
-        result = confirm(
-          'Are you sure?',
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(stdinLines: ['no'], () async {
+      result = confirm('Are you sure?', logger: logger);
+    });
 
-    await expectLater(
-      result,
-      completion(isFalse),
-    );
+    await expectLater(result, completion(isFalse));
   });
 
-  test(
-      'Given confirm prompt '
+  test('Given confirm prompt '
       'when providing valid input "n" '
       'then should return false', () async {
     late Future<bool> result;
-    await collectOutput(
-      stdinLines: ['n'],
-      () async {
-        result = confirm(
-          'Are you sure?',
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(stdinLines: ['n'], () async {
+      result = confirm('Are you sure?', logger: logger);
+    });
 
-    await expectLater(
-      result,
-      completion(isFalse),
-    );
+    await expectLater(result, completion(isFalse));
   });
 
-  test(
-      'Given confirm prompt '
+  test('Given confirm prompt '
       'when providing valid input capital "N" '
       'then should return false', () async {
     late Future<bool> result;
-    await collectOutput(
-      stdinLines: ['N'],
-      () async {
-        result = confirm(
-          'Are you sure?',
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(stdinLines: ['N'], () async {
+      result = confirm('Are you sure?', logger: logger);
+    });
 
-    await expectLater(
-      result,
-      completion(isFalse),
-    );
+    await expectLater(result, completion(isFalse));
   });
 
-  test(
-      'Given confirm prompt '
+  test('Given confirm prompt '
       'when providing invalid input "invalid" and then valid input "yes" '
       'then should prompt again and return true', () async {
     late Future<bool> result;
     var (:stdout, :stderr, :stdin) = await collectOutput(
       stdinLines: ['invalid', 'yes'],
       () {
-        result = confirm(
-          'Are you sure?',
-          logger: logger,
-        );
+        result = confirm('Are you sure?', logger: logger);
       },
     );
 
@@ -154,130 +90,89 @@ void main() {
       'Are you sure? [y/n]: ',
     );
 
-    await expectLater(
-      result,
-      completion(isTrue),
-    );
+    await expectLater(result, completion(isTrue));
   });
 
-  test(
-      'Given confirm prompt '
+  test('Given confirm prompt '
       'when providing empty input with default value false '
       'then should return false', () async {
     late bool result;
-    await collectOutput(
-      stdinLines: ['  '],
-      () async {
-        result = await confirm(
-          'Are you sure?',
-          defaultValue: false,
-          logger: logger,
-        );
-      },
-    );
-
-    await expectLater(
-      result,
-      isFalse,
-    );
+    await collectOutput(stdinLines: ['  '], () async {
+      result = await confirm(
+        'Are you sure?',
+        defaultValue: false,
+        logger: logger,
+      );
+    });
+
+    await expectLater(result, isFalse);
   });
 
-  test(
-      'Given confirm prompt '
+  test('Given confirm prompt '
       'when providing empty input with default value true '
       'then should return true', () async {
     late Future<bool> result;
-    await collectOutput(
-      stdinLines: ['  '],
-      () {
-        result = confirm(
-          'Are you sure?',
-          defaultValue: true,
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(stdinLines: ['  '], () {
+      result = confirm('Are you sure?', defaultValue: true, logger: logger);
+    });
 
-    await expectLater(
-      result,
-      completion(isTrue),
-    );
+    await expectLater(result, completion(isTrue));
   });
 
-  test(
-      'Given confirm prompt '
+  test('Given confirm prompt '
       'when providing empty input and then "yes" without default value '
       'then should prompt again and return true', () async {
     late Future<bool> result;
     var (:stdout, :stderr, :stdin) = await collectOutput(
       stdinLines: ['  ', 'yes'],
       () {
-        result = confirm(
-          'Are you sure?',
-          logger: logger,
-        );
+        result = confirm('Are you sure?', logger: logger);
       },
     );
 
     expect(
-        stdout.output,
-        'Are you sure? [y/n]: '
-        'Please enter "y" or "n".\n'
-        'Are you sure? [y/n]: ');
-
-    await expectLater(
-      result,
-      completion(isTrue),
+      stdout.output,
+      'Are you sure? [y/n]: '
+      'Please enter "y" or "n".\n'
+      'Are you sure? [y/n]: ',
     );
+
+    await expectLater(result, completion(isTrue));
   });
 
-  test(
-      'Given confirm prompt '
+  test('Given confirm prompt '
       'when providing no default value '
       'then should prompt with lowercase "y" and "n"', () async {
     var (:stdout, :stderr, :stdin) = await collectOutput(
       stdinLines: ['yes'],
       () async {
-        await confirm(
-          'Are you sure?',
-          logger: logger,
-        );
+        await confirm('Are you sure?', logger: logger);
       },
     );
 
     expect(stdout.output, 'Are you sure? [y/n]: ');
   });
 
-  test(
-      'Given confirm prompt '
+  test('Given confirm prompt '
       'when providing default value true '
       'then should prompt with uppercase "Y" and lowercase "n"', () async {
     var (:stdout, :stderr, :stdin) = await collectOutput(
       stdinLines: ['yes'],
       () async {
-        await confirm(
-          'Are you sure?',
-          defaultValue: true,
-          logger: logger,
-        );
+        await confirm('Are you sure?', defaultValue: true, logger: logger);
       },
     );
 
     expect(stdout.output, 'Are you sure? [Y/n]: ');
   });
 
-  test(
-      'Given confirm prompt '
+  test('Given confirm prompt '
       'when providing default value false '
       'then should prompt with lowercase "y" and uppercase "N"', () async {
     var (:stdout, :stderr, :stdin) = await collectOutput(
       stdinLines: ['yes'],
       () async {
-        await confirm(
-          'Are you sure?',
-          defaultValue: false,
-          logger: logger,
-        );
+        await confirm('Are you sure?', defaultValue: false, logger: logger);
       },
     );
 
diff --git a/test/prompts/input_test.dart b/test/prompts/input_test.dart
index 1979fd7..c160e7f 100644
--- a/test/prompts/input_test.dart
+++ b/test/prompts/input_test.dart
@@ -7,120 +7,74 @@ import '../test_utils/io_helper.dart';
 void main() {
   var logger = StdOutLogger(LogLevel.debug);
 
-  test(
-      'Given input prompt '
+  test('Given input prompt '
       'when providing valid input "HelloWorld" '
       'then should return the input', () async {
     late Future<String> result;
-    await collectOutput(
-      stdinLines: ['HelloWorld'],
-      () {
-        result = input(
-          'Enter something',
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(stdinLines: ['HelloWorld'], () {
+      result = input('Enter something', logger: logger);
+    });
 
-    await expectLater(
-      result,
-      completion('HelloWorld'),
-    );
+    await expectLater(result, completion('HelloWorld'));
   });
 
-  test(
-      'Given input prompt '
+  test('Given input prompt '
       'when providing empty input with default value "default" '
       'then should return "default"', () async {
     late Future<String> result;
-    await collectOutput(
-      stdinLines: [''],
-      () async {
-        result = input(
-          'Enter something',
-          defaultValue: 'default',
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(stdinLines: [''], () async {
+      result = input(
+        'Enter something',
+        defaultValue: 'default',
+        logger: logger,
+      );
+    });
 
-    await expectLater(
-      result,
-      completion('default'),
-    );
+    await expectLater(result, completion('default'));
   });
 
-  test(
-      'Given input prompt '
+  test('Given input prompt '
       'when providing empty input without default value '
       'then should return an empty string', () async {
     late Future<String> result;
-    await collectOutput(
-      stdinLines: [''],
-      () async {
-        result = input(
-          'Enter something',
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(stdinLines: [''], () async {
+      result = input('Enter something', logger: logger);
+    });
 
-    await expectLater(
-      result,
-      completion(''),
-    );
+    await expectLater(result, completion(''));
   });
 
-  test(
-      'Given input prompt '
+  test('Given input prompt '
       'when providing input with leading and trailing spaces '
       'then should trim string', () async {
     late Future<String> result;
-    await collectOutput(
-      stdinLines: ['   hello   '],
-      () async {
-        result = input(
-          'Enter something',
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(stdinLines: ['   hello   '], () async {
+      result = input('Enter something', logger: logger);
+    });
 
-    await expectLater(
-      result,
-      completion('hello'),
-    );
+    await expectLater(result, completion('hello'));
   });
 
-  test(
-      'Given input prompt '
+  test('Given input prompt '
       'when providing defult value '
       'then should display prompt with default value', () async {
     var (:stdout, :stderr, :stdin) = await collectOutput(
       stdinLines: [''],
       () async {
-        await input(
-          'Enter something',
-          defaultValue: 'default',
-          logger: logger,
-        );
+        await input('Enter something', defaultValue: 'default', logger: logger);
       },
     );
 
     expect(stdout.output, 'Enter something (default): ');
   });
 
-  test(
-      'Given input prompt '
+  test('Given input prompt '
       'when providing no default value '
       'then should not display a default description', () async {
     var (:stdout, :stderr, :stdin) = await collectOutput(
       stdinLines: ['value'],
       () async {
-        await input(
-          'Enter something',
-          logger: logger,
-        );
+        await input('Enter something', logger: logger);
       },
     );
 
diff --git a/test/prompts/multiple_select_test.dart b/test/prompts/multiple_select_test.dart
index 16d2b64..c948338 100644
--- a/test/prompts/multiple_select_test.dart
+++ b/test/prompts/multiple_select_test.dart
@@ -9,56 +9,41 @@ import '../test_utils/prompts/option_matcher.dart';
 void main() {
   var logger = StdOutLogger(LogLevel.debug);
 
-  test(
-      'Given multiselect prompt '
+  test('Given multiselect prompt '
       'when confirms selection with enter line-feed '
       'then completes', () async {
     late Future<List<Option>> result;
     var options = [Option('Option 1'), Option('Option 2'), Option('Option 3')];
 
-    await collectOutput(
-      keyInputs: [KeyCodes.enterLF],
-      () {
-        result = multiselect(
-          'Choose multiple options:',
-          options: options,
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(keyInputs: [KeyCodes.enterLF], () {
+      result = multiselect(
+        'Choose multiple options:',
+        options: options,
+        logger: logger,
+      );
+    });
 
-    await expectLater(
-      result,
-      completes,
-    );
+    await expectLater(result, completes);
   });
 
-  test(
-      'Given multiselect prompt '
+  test('Given multiselect prompt '
       'when confirms selection with enter carriage-return '
       'then completes', () async {
     late Future<List<Option>> result;
     var options = [Option('Option 1'), Option('Option 2'), Option('Option 3')];
 
-    await collectOutput(
-      keyInputs: [KeyCodes.enterCR],
-      () {
-        result = multiselect(
-          'Choose multiple options:',
-          options: options,
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(keyInputs: [KeyCodes.enterCR], () {
+      result = multiselect(
+        'Choose multiple options:',
+        options: options,
+        logger: logger,
+      );
+    });
 
-    await expectLater(
-      result,
-      completes,
-    );
+    await expectLater(result, completes);
   });
 
-  test(
-      'Given multiselect prompt '
+  test('Given multiselect prompt '
       'when providing message '
       'then should be displayed first', () async {
     var (:stdout, :stderr, :stdin) = await collectOutput(
@@ -75,8 +60,7 @@ void main() {
     expect(stdout.output, startsWith('Choose multiple options:\n'));
   });
 
-  test(
-      'Given select prompt '
+  test('Given select prompt '
       'when providing options '
       'then instruction should be given last', () async {
     var (:stdout, :stderr, :stdin) = await collectOutput(
@@ -92,14 +76,11 @@ void main() {
 
     expect(
       stdout.output,
-      endsWith(
-        'Press [Space] to toggle selection, [Enter] to confirm.\n',
-      ),
+      endsWith('Press [Space] to toggle selection, [Enter] to confirm.\n'),
     );
   });
 
-  test(
-      'Given multiselect prompt '
+  test('Given multiselect prompt '
       'when toggling multiple options and pressing Enter '
       'then should return all selected options', () async {
     late Future<List<Option>> result;
@@ -110,7 +91,7 @@ void main() {
         KeyCodes.space, // Select Option 1
         ...arrowDownSequence,
         KeyCodes.space, // Select Option 2
-        KeyCodes.enterCR
+        KeyCodes.enterCR,
       ],
       () {
         result = multiselect(
@@ -127,32 +108,24 @@ void main() {
     );
   });
 
-  test(
-      'Given multiselect prompt '
+  test('Given multiselect prompt '
       'when no options are selected and pressing Enter '
       'then should return an empty list', () async {
     late Future<List<Option>> result;
     var options = [Option('Option 1'), Option('Option 2'), Option('Option 3')];
 
-    await collectOutput(
-      keyInputs: [KeyCodes.enterCR],
-      () {
-        result = multiselect(
-          'Choose multiple options:',
-          options: options,
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(keyInputs: [KeyCodes.enterCR], () {
+      result = multiselect(
+        'Choose multiple options:',
+        options: options,
+        logger: logger,
+      );
+    });
 
-    await expectLater(
-      result,
-      completion(isEmpty),
-    );
+    await expectLater(result, completion(isEmpty));
   });
 
-  test(
-      'Given multiselect prompt '
+  test('Given multiselect prompt '
       'when toggling the same option twice '
       'then should return empty list', () async {
     late Future<List<Option>> result;
@@ -162,7 +135,7 @@ void main() {
       keyInputs: [
         KeyCodes.space, // Select option 1
         KeyCodes.space, // Deselect option 1
-        KeyCodes.enterCR
+        KeyCodes.enterCR,
       ],
       () {
         result = multiselect(
@@ -173,51 +146,35 @@ void main() {
       },
     );
 
-    await expectLater(
-      result,
-      completion(isEmpty),
-    );
+    await expectLater(result, completion(isEmpty));
   });
 
-  test(
-      'Given multiselect prompt '
+  test('Given multiselect prompt '
       'when pressing "q" key '
       'then should throw a cancellation exception', () async {
     var options = [Option('Option 1'), Option('Option 2'), Option('Option 3')];
 
-    var result = collectOutput(
-      keyInputs: [KeyCodes.q],
-      () async {
-        await multiselect(
-          'Choose multiple options:',
-          options: options,
-          logger: logger,
-        );
-      },
-    );
+    var result = collectOutput(keyInputs: [KeyCodes.q], () async {
+      await multiselect(
+        'Choose multiple options:',
+        options: options,
+        logger: logger,
+      );
+    });
 
-    await expectLater(
-      result,
-      throwsA(isA<ExitException>()),
-    );
+    await expectLater(result, throwsA(isA<ExitException>()));
   });
 
-  test(
-      'Given multiselect prompt '
+  test('Given multiselect prompt '
       'when providing empty options list '
       'then should throw ArgumentError', () async {
     expect(
-      () => multiselect(
-        'Choose an option:',
-        options: [],
-        logger: logger,
-      ),
+      () => multiselect('Choose an option:', options: [], logger: logger),
       throwsArgumentError,
     );
   });
 
-  test(
-      'Given multiselect prompt '
+  test('Given multiselect prompt '
       'when toggling multiple options and pressing Enter '
       'then all selected options should have filled radio button and '
       'current option should be underlined', () async {
@@ -226,7 +183,7 @@ void main() {
         KeyCodes.space, // Select Option 1
         ...arrowDownSequence,
         KeyCodes.space, // Select Option 2
-        KeyCodes.enterCR
+        KeyCodes.enterCR,
       ],
       () {
         return multiselect(
@@ -246,8 +203,7 @@ Press [Space] to toggle selection, [Enter] to confirm.
 ''');
   });
 
-  test(
-      'Given multiple select prompt with multiple options '
+  test('Given multiple select prompt with multiple options '
       'when moving past the last option and pressing Enter '
       'then first option is selected', () async {
     late Future<List<Option>> result;
@@ -259,7 +215,7 @@ Press [Space] to toggle selection, [Enter] to confirm.
         ...arrowDownSequence, // Move to Option 3
         ...arrowDownSequence, // Move to Option 1
         KeyCodes.space, // Select Option 1
-        KeyCodes.enterCR
+        KeyCodes.enterCR,
       ],
       () {
         result = multiselect(
diff --git a/test/prompts/select_test.dart b/test/prompts/select_test.dart
index b492693..0c51cdc 100644
--- a/test/prompts/select_test.dart
+++ b/test/prompts/select_test.dart
@@ -9,8 +9,7 @@ import '../test_utils/prompts/option_matcher.dart';
 void main() {
   var logger = StdOutLogger(LogLevel.debug);
 
-  test(
-      'Given select prompt '
+  test('Given select prompt '
       'when providing message '
       'then should be displayed first', () async {
     var (:stdout, :stderr, :stdin) = await collectOutput(
@@ -27,8 +26,7 @@ void main() {
     expect(stdout.output, startsWith('Choose an option:\n'));
   });
 
-  test(
-      'Given select prompt '
+  test('Given select prompt '
       'when providing options '
       'then instruction should be given last', () async {
     var (:stdout, :stderr, :stdin) = await collectOutput(
@@ -45,52 +43,33 @@ void main() {
     expect(stdout.output, endsWith('Press [Enter] to confirm.\n'));
   });
 
-  test(
-      'Given select prompt '
+  test('Given select prompt '
       'when selecting an option with Enter '
       'then should return the selected option', () async {
     late Future<Option> result;
     var options = [Option('Option 1'), Option('Option 2'), Option('Option 3')];
 
-    await collectOutput(
-      keyInputs: [KeyCodes.enterCR],
-      () {
-        result = select('Choose an option:', options: options, logger: logger);
-      },
-    );
+    await collectOutput(keyInputs: [KeyCodes.enterCR], () {
+      result = select('Choose an option:', options: options, logger: logger);
+    });
 
-    await expectLater(
-      result,
-      completion(equalsOption(Option('Option 1'))),
-    );
+    await expectLater(result, completion(equalsOption(Option('Option 1'))));
   });
 
-  test(
-      'Given select prompt '
+  test('Given select prompt '
       'when confirms selection with enter line-feed '
       'then completes', () async {
     late Future<Option> result;
     var options = [Option('Option 1'), Option('Option 2'), Option('Option 3')];
 
-    await collectOutput(
-      keyInputs: [KeyCodes.enterLF],
-      () {
-        result = select(
-          'Choose an option:',
-          options: options,
-          logger: logger,
-        );
-      },
-    );
+    await collectOutput(keyInputs: [KeyCodes.enterLF], () {
+      result = select('Choose an option:', options: options, logger: logger);
+    });
 
-    await expectLater(
-      result,
-      completes,
-    );
+    await expectLater(result, completes);
   });
 
-  test(
-      'Given select prompt '
+  test('Given select prompt '
       'when navigating with arrow keys '
       'then should return the highlighted option on Enter', () async {
     late Future<Option> result;
@@ -101,61 +80,42 @@ void main() {
         ...arrowDownSequence, // Go to option 2
         ...arrowDownSequence, // Go to option 3
         ...arrowUpSequence, // Go to option 2
-        KeyCodes.enterCR
+        KeyCodes.enterCR,
       ],
       () {
         result = select('Choose an option:', options: options, logger: logger);
       },
     );
 
-    await expectLater(
-      result,
-      completion(equalsOption(Option('Option 2'))),
-    );
+    await expectLater(result, completion(equalsOption(Option('Option 2'))));
   });
 
-  test(
-      'Given select prompt '
+  test('Given select prompt '
       'when pressing "q" key '
       'then should throw a cancellation exception', () async {
     var options = [Option('Option 1'), Option('Option 2'), Option('Option 3')];
 
-    var result = collectOutput(
-      keyInputs: [KeyCodes.q],
-      () async {
-        await select('Choose an option:', options: options, logger: logger);
-      },
-    );
+    var result = collectOutput(keyInputs: [KeyCodes.q], () async {
+      await select('Choose an option:', options: options, logger: logger);
+    });
 
-    await expectLater(
-      result,
-      throwsA(isA<ExitException>()),
-    );
+    await expectLater(result, throwsA(isA<ExitException>()));
   });
 
-  test(
-      'Given select prompt '
+  test('Given select prompt '
       'when providing empty options list '
       'then should throw ArgumentError', () async {
     expect(
-      () => select(
-        'Choose an option:',
-        options: [],
-        logger: logger,
-      ),
+      () => select('Choose an option:', options: [], logger: logger),
       throwsArgumentError,
     );
   });
 
-  test(
-      'Given select prompt '
+  test('Given select prompt '
       'when highlighting second option '
       'then radio button should be filled and option underlined', () async {
     var (:stdout, :stderr, :stdin) = await collectOutput(
-      keyInputs: [
-        ...arrowDownSequence,
-        KeyCodes.enterCR,
-      ],
+      keyInputs: [...arrowDownSequence, KeyCodes.enterCR],
       () {
         return select(
           'Choose an option:',
@@ -174,8 +134,7 @@ Press [Enter] to confirm.
 ''');
   });
 
-  test(
-      'Given select prompt with multiple options '
+  test('Given select prompt with multiple options '
       'when moving past the last option '
       'then should wrap around to the first option', () async {
     late Future<Option> result;
@@ -186,16 +145,13 @@ Press [Enter] to confirm.
         ...arrowDownSequence, // Go to option 2
         ...arrowDownSequence, // Go to option 3
         ...arrowDownSequence, // Go to option 1
-        KeyCodes.enterCR
+        KeyCodes.enterCR,
       ],
       () {
         result = select('Choose an option:', options: options, logger: logger);
       },
     );
 
-    await expectLater(
-      result,
-      completion(equalsOption(Option('Option 1'))),
-    );
+    await expectLater(result, completion(equalsOption(Option('Option 1'))));
   });
 }
diff --git a/test/pub_api_client_test.dart b/test/pub_api_client_test.dart
index bfd5e74..5d77ba0 100644
--- a/test/pub_api_client_test.dart
+++ b/test/pub_api_client_test.dart
@@ -26,134 +26,139 @@ abstract class PubApiClientTestConstants {
 
 void main() {
   test(
-      'Empty body and not found status response when fetching latest version exception with message is thrown.',
-      () async {
-    // Issue: https://github.com/leoafarias/pub_api_client/issues/35
-    var httpClient = createMockClient(
-      body: '',
-      status: HttpStatus.notFound,
-    );
-    var pubApiClient = PubApiClient(httpClient: httpClient);
-
-    await expectLater(
-      pubApiClient.tryFetchLatestStableVersion(
-        PubApiClientTestConstants.testPackageName,
-      ),
-      throwsA(
-        isA<VersionFetchException>().having(
-          (e) => e.message,
-          'message',
-          contains('Failed to fetch latest version for'),
+    'Empty body and not found status response when fetching latest version exception with message is thrown.',
+    () async {
+      // Issue: https://github.com/leoafarias/pub_api_client/issues/35
+      var httpClient = createMockClient(body: '', status: HttpStatus.notFound);
+      var pubApiClient = PubApiClient(httpClient: httpClient);
+
+      await expectLater(
+        pubApiClient.tryFetchLatestStableVersion(
+          PubApiClientTestConstants.testPackageName,
         ),
-      ),
-    );
-  });
+        throwsA(
+          isA<VersionFetchException>().having(
+            (e) => e.message,
+            'message',
+            contains('Failed to fetch latest version for'),
+          ),
+        ),
+      );
+    },
+  );
 
   test(
-      'Empty body and not found status response when fetching latest version then returns null.',
-      () async {
-    // Issue: https://github.com/leoafarias/pub_api_client/issues/35
-    var httpClient = createMockClient(
-      body: '',
-      status: HttpStatus.notFound,
-    );
-    var pubApiClient = PubApiClient(httpClient: httpClient);
-
-    await expectLater(
-      pubApiClient.tryFetchLatestStableVersion(
-        PubApiClientTestConstants.testPackageName,
-      ),
-      throwsA(
-        isA<VersionFetchException>().having(
-          (e) => e.message,
-          'message',
-          contains('Failed to fetch latest version for'),
+    'Empty body and not found status response when fetching latest version then returns null.',
+    () async {
+      // Issue: https://github.com/leoafarias/pub_api_client/issues/35
+      var httpClient = createMockClient(body: '', status: HttpStatus.notFound);
+      var pubApiClient = PubApiClient(httpClient: httpClient);
+
+      await expectLater(
+        pubApiClient.tryFetchLatestStableVersion(
+          PubApiClientTestConstants.testPackageName,
         ),
-      ),
-    );
-  });
+        throwsA(
+          isA<VersionFetchException>().having(
+            (e) => e.message,
+            'message',
+            contains('Failed to fetch latest version for'),
+          ),
+        ),
+      );
+    },
+  );
 
   test(
-      'Timeout is reached when fetching latest version then throws version fetch exception.',
-      () async {
-    var timeout = const Duration(milliseconds: 1);
-    var httpClient = createMockClient(
-      body: '',
-      status: HttpStatus.ok,
-      responseDelay:
-          timeout * 10, // Messaged is delayed longer than the timeout
-    );
-    var pubApiClient =
-        PubApiClient(httpClient: httpClient, requestTimeout: timeout);
-
-    await expectLater(
-      pubApiClient.tryFetchLatestStableVersion(
-          PubApiClientTestConstants.testPackageName),
-      throwsA(isA<VersionFetchException>()),
-    );
-  });
+    'Timeout is reached when fetching latest version then throws version fetch exception.',
+    () async {
+      var timeout = const Duration(milliseconds: 1);
+      var httpClient = createMockClient(
+        body: '',
+        status: HttpStatus.ok,
+        responseDelay:
+            timeout * 10, // Messaged is delayed longer than the timeout
+      );
+      var pubApiClient = PubApiClient(
+        httpClient: httpClient,
+        requestTimeout: timeout,
+      );
+
+      await expectLater(
+        pubApiClient.tryFetchLatestStableVersion(
+          PubApiClientTestConstants.testPackageName,
+        ),
+        throwsA(isA<VersionFetchException>()),
+      );
+    },
+  );
 
   test(
-      'Non stable version before stable version when fetching latest then returns first stable',
-      () async {
-    var expectedVersion = Version(1, 2, 3);
-    var httpClient = createMockClient(
-      body: '''
+    'Non stable version before stable version when fetching latest then returns first stable',
+    () async {
+      var expectedVersion = Version(1, 2, 3);
+      var httpClient = createMockClient(
+        body: '''
 {
     "name": "${PubApiClientTestConstants.testPackageName}",
     "versions": ["1.2.5-b", "1.2.4+a", "${expectedVersion.toString()}"]
 }
 ''',
-      status: HttpStatus.ok,
-    );
-    var pubApiClient = PubApiClient(httpClient: httpClient);
+        status: HttpStatus.ok,
+      );
+      var pubApiClient = PubApiClient(httpClient: httpClient);
 
-    var version = await pubApiClient
-        .tryFetchLatestStableVersion(PubApiClientTestConstants.testPackageName);
+      var version = await pubApiClient.tryFetchLatestStableVersion(
+        PubApiClientTestConstants.testPackageName,
+      );
 
-    expect(version, isNotNull);
-    expect(version, expectedVersion);
-  });
+      expect(version, isNotNull);
+      expect(version, expectedVersion);
+    },
+  );
 
-  test('Only non stable versions when fetching latest then returns null',
-      () async {
-    var httpClient = createMockClient(
-      body: '''
+  test(
+    'Only non stable versions when fetching latest then returns null',
+    () async {
+      var httpClient = createMockClient(
+        body: '''
 {
     "name": "${PubApiClientTestConstants.testPackageName}",
     "versions": ["1.2.5-b", "1.2.4+a"]
 }
 ''',
-      status: HttpStatus.ok,
-    );
-    var pubApiClient = PubApiClient(httpClient: httpClient);
+        status: HttpStatus.ok,
+      );
+      var pubApiClient = PubApiClient(httpClient: httpClient);
 
-    var version = await pubApiClient
-        .tryFetchLatestStableVersion(PubApiClientTestConstants.testPackageName);
+      var version = await pubApiClient.tryFetchLatestStableVersion(
+        PubApiClientTestConstants.testPackageName,
+      );
 
-    expect(version, isNull);
-  });
+      expect(version, isNull);
+    },
+  );
 
   test(
-      'Invalid version format when fetching latest from pub.dev then throws version parse exception.',
-      () async {
-    var httpClient = createMockClient(
-      body: '''
+    'Invalid version format when fetching latest from pub.dev then throws version parse exception.',
+    () async {
+      var httpClient = createMockClient(
+        body: '''
 {
     "name": "${PubApiClientTestConstants.testPackageName}",
     "versions": ["invalid_format"]
 }
 ''',
-      status: HttpStatus.ok,
-    );
-    var pubApiClient = PubApiClient(httpClient: httpClient);
-
-    await expectLater(
-      pubApiClient.tryFetchLatestStableVersion(
-          PubApiClientTestConstants.testPackageName),
-      throwsA(
-        isA<VersionParseException>(),
-      ),
-    );
-  });
+        status: HttpStatus.ok,
+      );
+      var pubApiClient = PubApiClient(httpClient: httpClient);
+
+      await expectLater(
+        pubApiClient.tryFetchLatestStableVersion(
+          PubApiClientTestConstants.testPackageName,
+        ),
+        throwsA(isA<VersionParseException>()),
+      );
+    },
+  );
 }
diff --git a/test/test_utils/io_helper.dart b/test/test_utils/io_helper.dart
index 6af0a0c..17c55fa 100644
--- a/test/test_utils/io_helper.dart
+++ b/test/test_utils/io_helper.dart
@@ -5,17 +5,14 @@ import 'mock_stdin.dart';
 import 'mock_stdout.dart';
 
 Future<({MockStdout stdout, MockStdout stderr, MockStdin stdin})>
-    collectOutput<T>(
+collectOutput<T>(
   FutureOr<T> Function() runner, {
   List<String> stdinLines = const [],
   List<int> keyInputs = const [],
 }) async {
   var standardOut = MockStdout();
   var standardError = MockStdout();
-  var standardIn = MockStdin(
-    textInputs: stdinLines,
-    keyInputs: keyInputs,
-  );
+  var standardIn = MockStdin(textInputs: stdinLines, keyInputs: keyInputs);
 
   await IOOverrides.runZoned(
     () async {
diff --git a/test/test_utils/mock_stdin.dart b/test/test_utils/mock_stdin.dart
index fd424dc..d8c8981 100644
--- a/test/test_utils/mock_stdin.dart
+++ b/test/test_utils/mock_stdin.dart
@@ -11,8 +11,8 @@ class MockStdin implements Stdin {
   MockStdin({
     List<String> textInputs = const [],
     List<int> keyInputs = const [],
-  })  : _textInputs = textInputs,
-        _keyInputs = keyInputs;
+  }) : _textInputs = textInputs,
+       _keyInputs = keyInputs;
 
   @override
   bool get echoMode => false;
@@ -29,9 +29,10 @@ class MockStdin implements Stdin {
   }
 
   @override
-  Stream<List<int>> asBroadcastStream(
-      {void Function(StreamSubscription<List<int>> subscription)? onListen,
-      void Function(StreamSubscription<List<int>> subscription)? onCancel}) {
+  Stream<List<int>> asBroadcastStream({
+    void Function(StreamSubscription<List<int>> subscription)? onListen,
+    void Function(StreamSubscription<List<int>> subscription)? onCancel,
+  }) {
     throw UnimplementedError();
   }
 
@@ -56,8 +57,9 @@ class MockStdin implements Stdin {
   }
 
   @override
-  Stream<List<int>> distinct(
-      [bool Function(List<int> previous, List<int> next)? equals]) {
+  Stream<List<int>> distinct([
+    bool Function(List<int> previous, List<int> next)? equals,
+  ]) {
     throw UnimplementedError();
   }
 
@@ -85,14 +87,18 @@ class MockStdin implements Stdin {
   Future<List<int>> get first => throw UnimplementedError();
 
   @override
-  Future<List<int>> firstWhere(bool Function(List<int> element) test,
-      {List<int> Function()? orElse}) {
+  Future<List<int>> firstWhere(
+    bool Function(List<int> element) test, {
+    List<int> Function()? orElse,
+  }) {
     throw UnimplementedError();
   }
 
   @override
   Future<S> fold<S>(
-      S initialValue, S Function(S previous, List<int> element) combine) {
+    S initialValue,
+    S Function(S previous, List<int> element) combine,
+  ) {
     throw UnimplementedError();
   }
 
@@ -102,8 +108,10 @@ class MockStdin implements Stdin {
   }
 
   @override
-  Stream<List<int>> handleError(Function onError,
-      {bool Function(dynamic error)? test}) {
+  Stream<List<int>> handleError(
+    Function onError, {
+    bool Function(dynamic error)? test,
+  }) {
     throw UnimplementedError();
   }
 
@@ -125,8 +133,10 @@ class MockStdin implements Stdin {
   Future<List<int>> get last => throw UnimplementedError();
 
   @override
-  Future<List<int>> lastWhere(bool Function(List<int> element) test,
-      {List<int> Function()? orElse}) {
+  Future<List<int>> lastWhere(
+    bool Function(List<int> element) test, {
+    List<int> Function()? orElse,
+  }) {
     throw UnimplementedError();
   }
 
@@ -134,8 +144,12 @@ class MockStdin implements Stdin {
   Future<int> get length => throw UnimplementedError();
 
   @override
-  StreamSubscription<List<int>> listen(void Function(List<int> event)? onData,
-      {Function? onError, void Function()? onDone, bool? cancelOnError}) {
+  StreamSubscription<List<int>> listen(
+    void Function(List<int> event)? onData, {
+    Function? onError,
+    void Function()? onDone,
+    bool? cancelOnError,
+  }) {
     throw UnimplementedError();
   }
 
@@ -158,8 +172,10 @@ class MockStdin implements Stdin {
   }
 
   @override
-  String? readLineSync(
-      {Encoding encoding = systemEncoding, bool retainNewlines = false}) {
+  String? readLineSync({
+    Encoding encoding = systemEncoding,
+    bool retainNewlines = false,
+  }) {
     if (_currentTextIndex < _textInputs.length) {
       return _textInputs[_currentTextIndex++];
     }
@@ -168,7 +184,8 @@ class MockStdin implements Stdin {
 
   @override
   Future<List<int>> reduce(
-      List<int> Function(List<int> previous, List<int> element) combine) {
+    List<int> Function(List<int> previous, List<int> element) combine,
+  ) {
     throw UnimplementedError();
   }
 
@@ -176,8 +193,10 @@ class MockStdin implements Stdin {
   Future<List<int>> get single => throw UnimplementedError();
 
   @override
-  Future<List<int>> singleWhere(bool Function(List<int> element) test,
-      {List<int> Function()? orElse}) {
+  Future<List<int>> singleWhere(
+    bool Function(List<int> element) test, {
+    List<int> Function()? orElse,
+  }) {
     throw UnimplementedError();
   }
 
@@ -205,8 +224,10 @@ class MockStdin implements Stdin {
   }
 
   @override
-  Stream<List<int>> timeout(Duration timeLimit,
-      {void Function(EventSink<List<int>> sink)? onTimeout}) {
+  Stream<List<int>> timeout(
+    Duration timeLimit, {
+    void Function(EventSink<List<int>> sink)? onTimeout,
+  }) {
     throw UnimplementedError();
   }
 
diff --git a/test/test_utils/prompts/key_code_sequence.dart b/test/test_utils/prompts/key_code_sequence.dart
index 5b4ca3e..84f820d 100644
--- a/test/test_utils/prompts/key_code_sequence.dart
+++ b/test/test_utils/prompts/key_code_sequence.dart
@@ -3,10 +3,10 @@ import 'package:cli_tools/src/prompts/key_codes.dart';
 var arrowUpSequence = [
   KeyCodes.escapeSequenceStart,
   KeyCodes.controlSequenceIntroducer,
-  KeyCodes.arrowUp
+  KeyCodes.arrowUp,
 ];
 var arrowDownSequence = [
   KeyCodes.escapeSequenceStart,
   KeyCodes.controlSequenceIntroducer,
-  KeyCodes.arrowDown
+  KeyCodes.arrowDown,
 ];
diff --git a/test/test_utils/prompts/option_matcher.dart b/test/test_utils/prompts/option_matcher.dart
index eed5d8a..361a9f6 100644
--- a/test/test_utils/prompts/option_matcher.dart
+++ b/test/test_utils/prompts/option_matcher.dart
@@ -52,8 +52,9 @@ class _EqualsAllOptionsMatcher extends Matcher {
 
     for (var i = 0; i < item.length; i++) {
       if (item[i].name != _expected[i].name) {
-        return mismatchDescription
-            .add('Option at index $i has name "${item[i].name}"');
+        return mismatchDescription.add(
+          'Option at index $i has name "${item[i].name}"',
+        );
       }
     }
 

From ea5a50e47467d11e23e012d012aa21dedd771949 Mon Sep 17 00:00:00 2001
From: Alexander Sandor <alexander@serverpod.dev>
Date: Wed, 19 Feb 2025 11:24:51 +0100
Subject: [PATCH 3/3] test(review): Add test for moving up past the first
 option.

---
 test/prompts/multiple_select_test.dart | 27 ++++++++++++++++++++++++++
 test/prompts/select_test.dart          | 19 ++++++++++++++++++
 2 files changed, 46 insertions(+)

diff --git a/test/prompts/multiple_select_test.dart b/test/prompts/multiple_select_test.dart
index c948338..e75e063 100644
--- a/test/prompts/multiple_select_test.dart
+++ b/test/prompts/multiple_select_test.dart
@@ -231,4 +231,31 @@ Press [Space] to toggle selection, [Enter] to confirm.
       completion(containsAllOptions([Option('Option 1')])),
     );
   });
+
+  test('Given multiple select prompt with multiple options '
+      'when up past the first option and pressing Enter '
+      'then last option is selected', () async {
+    late Future<List<Option>> result;
+    var options = [Option('Option 1'), Option('Option 2'), Option('Option 3')];
+
+    await collectOutput(
+      keyInputs: [
+        ...arrowUpSequence, // Move to Option 3
+        KeyCodes.space, // Select Option 3
+        KeyCodes.enterCR,
+      ],
+      () {
+        result = multiselect(
+          'Choose multiple options:',
+          options: options,
+          logger: logger,
+        );
+      },
+    );
+
+    await expectLater(
+      result,
+      completion(containsAllOptions([Option('Option 3')])),
+    );
+  });
 }
diff --git a/test/prompts/select_test.dart b/test/prompts/select_test.dart
index 0c51cdc..0ba9fe5 100644
--- a/test/prompts/select_test.dart
+++ b/test/prompts/select_test.dart
@@ -154,4 +154,23 @@ Press [Enter] to confirm.
 
     await expectLater(result, completion(equalsOption(Option('Option 1'))));
   });
+
+  test('Given select prompt with multiple options '
+      'when moving up past the first option '
+      'then should wrap around to the last option', () async {
+    late Future<Option> result;
+    var options = [Option('Option 1'), Option('Option 2'), Option('Option 3')];
+
+    await collectOutput(
+      keyInputs: [
+        ...arrowUpSequence, // Go to option 3
+        KeyCodes.enterCR,
+      ],
+      () {
+        result = select('Choose an option:', options: options, logger: logger);
+      },
+    );
+
+    await expectLater(result, completion(equalsOption(Option('Option 3'))));
+  });
 }