⬆️ Updated lints dependencies and updated formatting.

Also added small explaining on Future.error usage.

Author: Guldem

README.md

@@ -256,6 +256,10 @@ parameterizedTest('Example of CSV data',
 });
 ```
 
+### Testing with `Future.error` values
+When using `Future.error` directly in your parameterized test values, this might leads to not executing tests at all. In order to handle this correctly your can provide the `Future` as a callback function.  
+But also need to make sure that the when the future is awaited its also catch. `Future.error` will throw the provided object. See [23](https://github.com/DutchCodingCompany/parameterized_test/issues/23) for more information.
+
 ## Additional information 💡
 
 It's just a simple wrapper to easily execute tests multiple times with different values. Feel free to

analysis_options.yaml

@@ -1,5 +1,8 @@
 include: package:very_good_analysis/analysis_options.yaml
 
+formatter:
+  trailing_commas: automate
+
 analyzer:
   errors:
     unawaited_futures: warning

example/parameterized_test_example.dart

@@ -1,3 +1,4 @@
+// ignore this lint for example reasons.
 // ignore_for_file: avoid_print
 
 import 'package:csv/csv.dart';
@@ -6,46 +7,44 @@ import 'package:test/test.dart';
 
 void main() {
   // Simple test containing a list of single values
+  parameterizedTest('Example of list of single values', [1, 2, 3], (int value) {
+    final result = value < 4;
+    expect(result, true);
+  });
+
+  // Simple test containing a list of multiple values
   parameterizedTest(
-    'Example of list of single values',
+    'Example of list of multiple values',
     [
-      1,
-      2,
-      3,
+      [0, 1, 1],
+      [1, 1, 2],
+      [1, 2, 3],
+      [2, 2, 4],
     ],
-    (int value) {
-      final result = value < 4;
-      expect(result, true);
+    (int value1, int value2, int sum) {
+      expect(value1 + value2, sum);
     },
   );
 
-  // Simple test containing a list of multiple values
-  parameterizedTest('Example of list of multiple values', [
-    [0, 1, 1],
-    [1, 1, 2],
-    [1, 2, 3],
-    [2, 2, 4],
-  ], (int value1, int value2, int sum) {
-    expect(value1 + value2, sum);
-  });
-
   // Test containing a list with complex objects
-  parameterizedTest('Example of a list with complex object', [
-    [DateTime(2024, 4, 12), 5],
-    [DateTime(1969, 07, 20), 7],
-  ], (DateTime dateTime, int expectedWeekday) {
-    expect(dateTime.weekday, expectedWeekday);
-  });
-
-  // Test containing a list of enums
   parameterizedTest(
-    'Example using enum as value',
-    FruitEnum.values,
-    (FruitEnum testEnum) {
-      expect(testEnum.name.length, testEnum.wordLength);
+    'Example of a list with complex object',
+    [
+      [DateTime(2024, 4, 12), 5],
+      [DateTime(1969, 07, 20), 7],
+    ],
+    (DateTime dateTime, int expectedWeekday) {
+      expect(dateTime.weekday, expectedWeekday);
     },
   );
 
+  // Test containing a list of enums
+  parameterizedTest('Example using enum as value', FruitEnum.values, (
+    FruitEnum testEnum,
+  ) {
+    expect(testEnum.name.length, testEnum.wordLength);
+  });
+
   // Test retreiving the list of values from a function
   List<dynamic> provideData() {
     return [
@@ -56,13 +55,13 @@ void main() {
     ];
   }
 
-  parameterizedTest(
-    'Example of list of values from function',
-    provideData(),
-    (int value1, int value2, int sum) {
-      expect(value1 + value2, sum);
-    },
-  );
+  parameterizedTest('Example of list of values from function', provideData(), (
+    int value1,
+    int value2,
+    int sum,
+  ) {
+    expect(value1 + value2, sum);
+  });
 
   // Simple test with setup and teardown
   parameterizedTest(
@@ -88,28 +87,24 @@ void main() {
   // But this is not a good practice to use a delay like
   // this in a test. Running this test will take longer. This could be
   // fixed by using a package like fake_async.
-  parameterizedTest(
-    'Example using a async test',
-    [
-      100,
-      200,
-      300,
-    ],
-    (int value) async {
-      final millis = DateTime.now().millisecondsSinceEpoch;
-      await Future<void>.delayed(Duration(milliseconds: value));
-      final passed = DateTime.now().millisecondsSinceEpoch - millis;
+  parameterizedTest('Example using a async test', [100, 200, 300], (
+    int value,
+  ) async {
+    final millis = DateTime.now().millisecondsSinceEpoch;
+    await Future<void>.delayed(Duration(milliseconds: value));
+    final passed = DateTime.now().millisecondsSinceEpoch - millis;
 
-      expect(passed >= value, true);
-    },
-  );
+    expect(passed >= value, true);
+  });
 
   // Test with CSV data
-  parameterizedTest('Example of CSV data',
-      const CsvToListConverter().convert('kiwi,4\r\napple,5\r\nbanana,6'),
-      (String fruit, int length) {
-    expect(fruit.length, length);
-  });
+  parameterizedTest(
+    'Example of CSV data',
+    const CsvToListConverter().convert('kiwi,4\r\napple,5\r\nbanana,6'),
+    (String fruit, int length) {
+      expect(fruit.length, length);
+    },
+  );
 }
 
 enum FruitEnum {

lib/parameterized_test.dart

@@ -1,5 +1,5 @@
 /// A library that simplifies writing parameterized tests in Dart.
-library parameterized_test;
+library;
 
 export '/src/parameterized_test.dart'
     show parameterizedGroup, parameterizedTest;

lib/src/errors/parameterized_error.dart

@@ -8,18 +8,16 @@ class ParameterizedError extends Error {
 
   /// Creates a [ParameterizedError] from a [TypeError].
   /// When arguments types don't match the function arguments types.
-  factory ParameterizedError.forTypeError(
-    List<dynamic> value,
-    Function body,
-  ) {
+  factory ParameterizedError.forTypeError(List<dynamic> value, Function body) {
     final bodyClosure = extractFunctionArgumentsSignature(body.toString());
 
     return ParameterizedError(
-        "Provided value(s) didn't match the function arguments types.\n"
-        'Test values: $value\n'
-        'Provided types: '
-        '(${value.map((e) => e.runtimeType).join(', ')})\n'
-        'Expected types: ($bodyClosure)');
+      "Provided value(s) didn't match the function arguments types.\n"
+      'Test values: $value\n'
+      'Provided types: '
+      '(${value.map((e) => e.runtimeType).join(', ')})\n'
+      'Expected types: ($bodyClosure)',
+    );
   }
 
   /// Creates a [ParameterizedError] from a [TypeError].
@@ -32,13 +30,14 @@ class ParameterizedError extends Error {
     final positionalArgumentsCount = ','.allMatches(bodyClosure).length + 1;
 
     return ParameterizedError(
-        "Provided value(s) didn't match the function arguments count.\n"
-        'Amount of provided values: ${value.length}\n'
-        'Expected function arguments: $positionalArgumentsCount\n'
-        'Test values: $value\n'
-        'Provided types: '
-        '(${value.map((e) => e.runtimeType).join(', ')})\n'
-        'Expected types: ($bodyClosure)');
+      "Provided value(s) didn't match the function arguments count.\n"
+      'Amount of provided values: ${value.length}\n'
+      'Expected function arguments: $positionalArgumentsCount\n'
+      'Test values: $value\n'
+      'Provided types: '
+      '(${value.map((e) => e.runtimeType).join(', ')})\n'
+      'Expected types: ($bodyClosure)',
+    );
   }
 
   /// Error message.
@@ -51,10 +50,7 @@ class ParameterizedError extends Error {
     final closureIndex = body.indexOf(closure);
     final endIndex = body.indexOf(')', closureIndex);
 
-    final bodyClosure = body.substring(
-      closureIndex + closure.length,
-      endIndex,
-    );
+    final bodyClosure = body.substring(closureIndex + closure.length, endIndex);
 
     return bodyClosure.replaceAll(RegExp('<(.*)>'), '');
   }

lib/src/errors/stack_trace_extension.dart

@@ -27,8 +27,6 @@ extension StackTraceExtension on StackTrace {
 
     final frames = trace.frames.take(index).toList();
 
-    return !frames.every(
-      (f) => f.package == 'parameterized_test' || f.isCore,
-    );
+    return !frames.every((f) => f.package == 'parameterized_test' || f.isCore);
   }
 }

lib/src/parameterized_test.dart

@@ -5,16 +5,17 @@ import 'package:parameterized_test/src/test_options/value_with_test_options.dart
 import 'package:test/test.dart';
 
 /// Callback signature for test and group functions.
-typedef TestFunc = void Function(
-  Object? description,
-  dynamic Function() body, {
-  String? testOn,
-  Timeout? timeout,
-  Object? skip,
-  Object? tags,
-  Map<String, dynamic>? onPlatform,
-  int? retry,
-});
+typedef TestFunc =
+    void Function(
+      Object? description,
+      dynamic Function() body, {
+      String? testOn,
+      Timeout? timeout,
+      Object? skip,
+      Object? tags,
+      Map<String, dynamic>? onPlatform,
+      int? retry,
+    });
 
 /// Callback signature for setUp and tearDown functions.
 typedef SetupFunc = void Function(dynamic Function());
@@ -42,12 +43,8 @@ typedef SetupFunc = void Function(dynamic Function());
 /// ```
 /// {@endtemplate}
 @isTestGroup
-ParameterizedTest get parameterizedTest => const ParameterizedTestImpl(
-      group,
-      test,
-      setUp,
-      tearDown,
-    );
+ParameterizedTest get parameterizedTest =>
+    const ParameterizedTestImpl(group, test, setUp, tearDown);
 
 /// {@template parameterizedGroup}
 // ignore: comment_references
@@ -76,12 +73,8 @@ ParameterizedTest get parameterizedTest => const ParameterizedTestImpl(
 /// ```
 /// {@endtemplate}
 @isTestGroup
-ParameterizedTest get parameterizedGroup => const ParameterizedTestImpl(
-      group,
-      group,
-      setUp,
-      tearDown,
-    );
+ParameterizedTest get parameterizedGroup =>
+    const ParameterizedTestImpl(group, group, setUp, tearDown);
 
 /// {@template ParameterizedTest}
 /// Implementation of parameterized test.
@@ -159,17 +152,16 @@ class ParameterizedTestImpl implements ParameterizedTest {
             testDescription,
             () {
               try {
-                return Function.apply(
-                  body,
-                  value,
-                );
+                return Function.apply(body, value);
               }
+              // We want to catch these errors to provide better error messages
               //ignore: avoid_catching_errors
               on NoSuchMethodError catch (e, s) {
                 if (s.isInsideTestBody) rethrow;
 
                 throw ParameterizedError.fromNoSuchMethodError(e, value);
               }
+              // We want to catch these errors to provide better error messages
               //ignore: avoid_catching_errors
               on TypeError catch (e, s) {
                 if (s.isInsideTestBody) rethrow;
@@ -206,9 +198,7 @@ class ParameterizedTestImpl implements ParameterizedTest {
     List<dynamic> value,
     CustomDescriptionBuilder? customDescriptionBuilder,
   ) {
-    final mappedValues = value.map(
-      (e) => e is String ? "'$e'" : e.toString(),
-    );
+    final mappedValues = value.map((e) => e is String ? "'$e'" : e.toString());
 
     return customDescriptionBuilder?.call(description, index, value) ??
         '[ ${mappedValues.join(', ')} ]';
@@ -217,9 +207,9 @@ class ParameterizedTestImpl implements ParameterizedTest {
   /// Unpack wrapped values and test options.
   /// Handle different types of values.
   ValueWithTestOptions parseValues(dynamic value) => switch (value) {
-        ValueWithTestOptions() => value,
-        List() => (values: value, testOptions: null),
-        Iterable() => (values: value.toList(), testOptions: null),
-        _ => (values: [value], testOptions: null),
-      };
+    ValueWithTestOptions() => value,
+    List() => (values: value, testOptions: null),
+    Iterable() => (values: value.toList(), testOptions: null),
+    _ => (values: [value], testOptions: null),
+  };
 }