diff --git a/lib/main.dart b/lib/main.dart index cecaeb70..4ab02252 100644 --- a/lib/main.dart +++ b/lib/main.dart @@ -7,8 +7,11 @@ import 'package:solid_lints/src/lints/avoid_final_with_getter/fixes/avoid_final_ import 'package:solid_lints/src/lints/avoid_global_state/avoid_global_state_rule.dart'; import 'package:solid_lints/src/lints/avoid_non_null_assertion/avoid_non_null_assertion_rule.dart'; import 'package:solid_lints/src/lints/avoid_returning_widgets/avoid_returning_widgets_rule.dart'; +import 'package:solid_lints/src/lints/avoid_unnecessary_return_variable/avoid_unnecessary_return_variable_rule.dart'; +import 'package:solid_lints/src/lints/avoid_unnecessary_setstate/avoid_unnecessary_set_state_rule.dart'; import 'package:solid_lints/src/lints/avoid_unnecessary_type_assertions/avoid_unnecessary_type_assertions_rule.dart'; import 'package:solid_lints/src/lints/avoid_unnecessary_type_assertions/fixes/avoid_unnecessary_type_assertions_fix.dart'; +import 'package:solid_lints/src/lints/avoid_unrelated_type_assertions/avoid_unrelated_type_assertions_rule.dart'; import 'package:solid_lints/src/lints/avoid_unused_parameters/avoid_unused_parameters_rule.dart'; import 'package:solid_lints/src/lints/cyclomatic_complexity/cyclomatic_complexity_rule.dart'; import 'package:solid_lints/src/lints/double_literal_format/double_literal_format_rule.dart'; @@ -17,11 +20,14 @@ import 'package:solid_lints/src/lints/function_lines_of_code/function_lines_of_c import 'package:solid_lints/src/lints/member_ordering/member_ordering_rule.dart'; import 'package:solid_lints/src/lints/named_parameters_ordering/fixes/named_parameters_ordering_fix.dart'; import 'package:solid_lints/src/lints/named_parameters_ordering/named_parameters_ordering_rule.dart'; +import 'package:solid_lints/src/lints/newline_before_return/newline_before_return_rule.dart'; import 'package:solid_lints/src/lints/no_empty_block/no_empty_block_rule.dart'; +import 'package:solid_lints/src/lints/no_equal_then_else/no_equal_then_else_rule.dart'; import 'package:solid_lints/src/lints/no_magic_number/no_magic_number_rule.dart'; import 'package:solid_lints/src/lints/number_of_parameters/number_of_parameters_rule.dart'; import 'package:solid_lints/src/lints/prefer_conditional_expressions/fixes/prefer_conditional_expressions_fix.dart'; import 'package:solid_lints/src/lints/prefer_conditional_expressions/prefer_conditional_expressions_rule.dart'; +import 'package:solid_lints/src/lints/prefer_early_return/prefer_early_return_rule.dart'; import 'package:solid_lints/src/lints/prefer_first/fixes/prefer_first_fix.dart'; import 'package:solid_lints/src/lints/prefer_first/prefer_first_rule.dart'; import 'package:solid_lints/src/lints/prefer_last/fixes/prefer_last_fix.dart'; @@ -81,6 +87,12 @@ class SolidLintsPlugin extends Plugin { // TODO: Add more lint rules and use analysisLoader // for rules that need parameters // For example: `CyclomaticComplexityRule(analysisLoader)` + AvoidUnnecessaryReturnVariableRule(), + AvoidUnnecessarySetStateRule(), + AvoidUnrelatedTypeAssertionsRule(), + NewlineBeforeReturnRule(), + NoEqualThenElseRule(), + PreferEarlyReturnRule(), ]; for (final lintRule in lintRules) { diff --git a/test/lints/auto_test_lint_offsets.dart b/test/lints/auto_test_lint_offsets.dart index a9b4b298..b4b41fbb 100644 --- a/test/lints/auto_test_lint_offsets.dart +++ b/test/lints/auto_test_lint_offsets.dart @@ -2,17 +2,19 @@ import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; import 'package:analyzer_testing/src/analysis_rule/pub_package_resolution.dart'; import 'package:collection/collection.dart'; +import '../src/utils/auto_lint_data.dart'; + mixin AutoTestLintOffsets on AnalysisRuleTest { int _nextPlaceholderId = 0; - final Map _placeholderToCode = {}; + final Map _placeholderToData = {}; Future assertAutoDiagnostics(String source) async { try { - final placeholders = _placeholderToCode.entries + final placeholders = _placeholderToData.entries .map( (entry) => ( placeholder: entry.key, - code: entry.value, + data: entry.value, index: source.indexOf(entry.key), ), ) @@ -29,27 +31,46 @@ mixin AutoTestLintOffsets on AnalysisRuleTest { } expectedDiagnostics.add( - lint(match.index + replacedPlaceholdersDelta, match.code.length), + lint( + match.index + replacedPlaceholdersDelta, + match.data.code.length, + correctionContains: match.data.correctionContains, + messageContainsAll: match.data.messageContainsAll, + name: match.data.name, + contextMessages: match.data.contextMessages, + ), ); replacedPlaceholdersDelta += - match.code.length - match.placeholder.length; + match.data.code.length - match.placeholder.length; } - final resolvedSource = _placeholderToCode.entries.fold( + final resolvedSource = _placeholderToData.entries.fold( source, - (resolved, entry) => resolved.replaceFirst(entry.key, entry.value), + (resolved, entry) => resolved.replaceFirst(entry.key, entry.value.code), ); await assertDiagnostics(resolvedSource, expectedDiagnostics); } finally { _nextPlaceholderId = 0; - _placeholderToCode.clear(); + _placeholderToData.clear(); } } - String expectLint(String code) { + String expectLint( + String code, { + Pattern? correctionContains, + List messageContainsAll = const [], + String? name, + List? contextMessages, + }) { final placeholder = '__AUTO_TEST_LINT_${_nextPlaceholderId++}__'; - _placeholderToCode[placeholder] = code; + _placeholderToData[placeholder] = AutoLintData( + code: code, + correctionContains: correctionContains, + messageContainsAll: messageContainsAll, + name: name, + contextMessages: contextMessages, + ); return placeholder; } } diff --git a/test/lints/avoid_debug_print_in_release/avoid_debug_print_in_release_rule_test.dart b/test/lints/avoid_debug_print_in_release/avoid_debug_print_in_release_rule_test.dart index 74c6554b..1848496e 100644 --- a/test/lints/avoid_debug_print_in_release/avoid_debug_print_in_release_rule_test.dart +++ b/test/lints/avoid_debug_print_in_release/avoid_debug_print_in_release_rule_test.dart @@ -2,6 +2,8 @@ import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; import 'package:solid_lints/src/lints/avoid_debug_print_in_release/avoid_debug_print_in_release_rule.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; +import '../auto_test_lint_offsets.dart'; + void main() { defineReflectiveSuite(() { defineReflectiveTests(AvoidDebugPrintInReleaseRuleTest); @@ -9,7 +11,8 @@ void main() { } @reflectiveTest -class AvoidDebugPrintInReleaseRuleTest extends AnalysisRuleTest { +class AvoidDebugPrintInReleaseRuleTest extends AnalysisRuleTest + with AutoTestLintOffsets { @override void setUp() { final flutter = newPackage('flutter'); @@ -33,81 +36,62 @@ export 'package:flutter/foundation.dart'; super.setUp(); } - @override - String get analysisRule => AvoidDebugPrintInReleaseRule.lintName; - - void test_reports_debug_print_with_package_import() async { - await assertDiagnostics( - r''' + Future test_reports_debug_print_with_package_import() async { + await assertAutoDiagnostics(''' import 'package:flutter/foundation.dart'; void test() { - debugPrint('This should be flagged'); + ${expectLint('debugPrint')}('This should be flagged'); } -''', - [lint(59, 10)], - ); +'''); } - void test_reports_aliased_debug_print_from_package() async { - await assertDiagnostics( - r''' + Future test_reports_aliased_debug_print_from_package() async { + await assertAutoDiagnostics(''' import 'package:flutter/foundation.dart' as f; void test() { - f.debugPrint('This should be flagged'); + f.${expectLint('debugPrint')}('This should be flagged'); } -''', - [lint(66, 10)], - ); +'''); } - void test_reports_debug_print_as_callback() async { - await assertDiagnostics( - r''' + Future test_reports_debug_print_as_callback() async { + await assertAutoDiagnostics(''' import 'package:flutter/foundation.dart'; void test() { - ['a'].forEach(debugPrint); + ['a'].forEach(${expectLint('debugPrint')}); } -''', - [lint(73, 10)], - ); +'''); } - void test_reports_inside_kReleaseMode_guard() async { - await assertDiagnostics( - r''' + Future test_reports_inside_kReleaseMode_guard() async { + await assertAutoDiagnostics(''' import 'package:flutter/foundation.dart'; void test() { if (kReleaseMode) { - debugPrint('This should be flagged'); + ${expectLint('debugPrint')}('This should be flagged'); } } -''', - [lint(83, 10)], - ); +'''); } - void test_reports_inside_not_kDebugMode_guard() async { - await assertDiagnostics( - r''' + Future test_reports_inside_not_kDebugMode_guard() async { + await assertAutoDiagnostics(''' import 'package:flutter/foundation.dart'; void test() { if (!kDebugMode) { - debugPrint('Should still be flagged'); + ${expectLint('debugPrint')}('Should still be flagged'); } } -''', - [lint(82, 10)], - ); +'''); } - void test_does_not_report_inside_not_kReleaseMode() async { - await assertNoDiagnostics( - r''' + Future test_does_not_report_inside_not_kReleaseMode() async { + await assertNoDiagnostics(r''' import 'package:flutter/foundation.dart'; void test() { @@ -115,13 +99,11 @@ void test() { debugPrint('Safe'); } } -''', - ); +'''); } - void test_does_not_report_inside_kDebugMode() async { - await assertNoDiagnostics( - r''' + Future test_does_not_report_inside_kDebugMode() async { + await assertNoDiagnostics(r''' import 'package:flutter/foundation.dart'; void test() { @@ -129,58 +111,46 @@ void test() { debugPrint('Safe'); } } -''', - ); +'''); } - void test_no_report_when_debugPrint_is_not_from_foundation() async { - await assertNoDiagnostics( - r''' + Future test_no_report_when_debugPrint_is_not_from_foundation() async { + await assertNoDiagnostics(r''' void debugPrint(String message) {} void test() { debugPrint('Not a flutter call'); } -''', - ); +'''); } - void test_reports_when_imported_via_material() async { - await assertDiagnostics( - r''' + Future test_reports_when_imported_via_material() async { + await assertAutoDiagnostics(''' import 'package:flutter/material.dart'; void test() { - debugPrint('Flagged via material'); + ${expectLint('debugPrint')}('Flagged via material'); } -''', - [lint(57, 10)], - ); +'''); } - void test_reports_when_imported_via_cupertino() async { - await assertDiagnostics( - r''' + Future test_reports_when_imported_via_cupertino() async { + await assertAutoDiagnostics(''' import 'package:flutter/cupertino.dart'; void test() { - debugPrint('Flagged via cupertino'); + ${expectLint('debugPrint')}('Flagged via cupertino'); } -''', - [lint(58, 10)], - ); +'''); } - void test_reports_debug_print_call_method() async { - await assertDiagnostics( - r''' + Future test_reports_debug_print_call_method() async { + await assertAutoDiagnostics(''' import 'package:flutter/foundation.dart'; void test() { - debugPrint.call('This should be flagged'); + ${expectLint('debugPrint')}.call('This should be flagged'); } -''', - [lint(59, 10)], - ); +'''); } } diff --git a/test/lints/avoid_global_state/avoid_global_state_rule_test.dart b/test/lints/avoid_global_state/avoid_global_state_rule_test.dart index 29616804..2ba14682 100644 --- a/test/lints/avoid_global_state/avoid_global_state_rule_test.dart +++ b/test/lints/avoid_global_state/avoid_global_state_rule_test.dart @@ -2,6 +2,8 @@ import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; import 'package:solid_lints/src/lints/avoid_global_state/avoid_global_state_rule.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; +import '../auto_test_lint_offsets.dart'; + void main() { defineReflectiveSuite(() { defineReflectiveTests(AvoidGlobalStateRuleTest); @@ -9,47 +11,42 @@ void main() { } @reflectiveTest -class AvoidGlobalStateRuleTest extends AnalysisRuleTest { +class AvoidGlobalStateRuleTest extends AnalysisRuleTest + with AutoTestLintOffsets { @override void setUp() { rule = AvoidGlobalStateRule(); super.setUp(); } - void test_reports_mutable_top_level_variable() async { - await assertDiagnostics( - r''' -var globalMutable = 0; -''', - [lint(4, 17)], - ); + Future test_reports_mutable_top_level_variable() async { + await assertAutoDiagnostics(''' +var ${expectLint('globalMutable = 0')}; +'''); } - void test_reports_mutable_static_field() async { - await assertDiagnostics( - r''' + Future test_reports_mutable_static_field() async { + await assertAutoDiagnostics(''' class Test { - static int staticMutable = 0; + static int ${expectLint('staticMutable = 0')}; } -''', - [lint(26, 17)], - ); +'''); } - void test_does_not_report_global_immutable_variables() async { + Future test_does_not_report_global_immutable_variables() async { await assertNoDiagnostics(r''' final globalFinal = 1; const globalConst = 1; '''); } - void test_does_not_report_global_private_variables() async { + Future test_does_not_report_global_private_variables() async { await assertNoDiagnostics(r''' var _privateTopLevel = 0; '''); } - void test_does_not_report_class_level_immutable_variables() async { + Future test_does_not_report_class_level_immutable_variables() async { await assertNoDiagnostics(r''' class Test { static final int staticFinal = 1; @@ -58,7 +55,7 @@ class Test { '''); } - void test_does_not_report_class_level_private_variables() async { + Future test_does_not_report_class_level_private_variables() async { await assertNoDiagnostics(r''' class Test { static int _staticPrivate = 0; @@ -66,7 +63,7 @@ class Test { '''); } - void test_does_not_report_local_variables() async { + Future test_does_not_report_local_variables() async { await assertNoDiagnostics(r''' void m() { int localMutable = 0; diff --git a/test/lints/avoid_non_null_assertion/avoid_non_null_assertion_rule_test.dart b/test/lints/avoid_non_null_assertion/avoid_non_null_assertion_rule_test.dart index 8d054cda..10cf6ced 100644 --- a/test/lints/avoid_non_null_assertion/avoid_non_null_assertion_rule_test.dart +++ b/test/lints/avoid_non_null_assertion/avoid_non_null_assertion_rule_test.dart @@ -2,6 +2,8 @@ import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; import 'package:solid_lints/src/lints/avoid_non_null_assertion/avoid_non_null_assertion_rule.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; +import '../auto_test_lint_offsets.dart'; + void main() { defineReflectiveSuite(() { defineReflectiveTests(AvoidNonNullAssertionRuleTest); @@ -9,36 +11,31 @@ void main() { } @reflectiveTest -class AvoidNonNullAssertionRuleTest extends AnalysisRuleTest { +class AvoidNonNullAssertionRuleTest extends AnalysisRuleTest + with AutoTestLintOffsets { @override void setUp() { rule = AvoidNonNullAssertionRule(); super.setUp(); } - void test_reports_non_null_assertion_on_nullable_value() async { - await assertDiagnostics( - r''' + Future test_reports_non_null_assertion_on_nullable_value() async { + await assertAutoDiagnostics(''' void m(int? number) { - final value = number!; + final value = ${expectLint('number!')}; } -''', - [lint(38, 7)], - ); +'''); } - void test_reports_non_null_assertion_on_method_call() async { - await assertDiagnostics( - r''' + Future test_reports_non_null_assertion_on_method_call() async { + await assertAutoDiagnostics(''' void m(Object? object) { - object!.toString(); + ${expectLint('object!')}.toString(); } -''', - [lint(27, 7)], - ); +'''); } - void test_does_not_report_map_access() async { + Future test_does_not_report_map_access() async { await assertNoDiagnostics(r''' void m() { final map = {'key': 'value'}; @@ -47,7 +44,7 @@ void m() { '''); } - void test_does_not_report_safe_null_check() async { + Future test_does_not_report_safe_null_check() async { await assertNoDiagnostics(r''' void m(int? number) { if (number != null) { diff --git a/test/lints/avoid_unnecessary_return_variable/avoid_unnecessary_return_variable_rule_test.dart b/test/lints/avoid_unnecessary_return_variable/avoid_unnecessary_return_variable_rule_test.dart index 704cc16d..0ebfa056 100644 --- a/test/lints/avoid_unnecessary_return_variable/avoid_unnecessary_return_variable_rule_test.dart +++ b/test/lints/avoid_unnecessary_return_variable/avoid_unnecessary_return_variable_rule_test.dart @@ -2,6 +2,8 @@ import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; import 'package:solid_lints/src/lints/avoid_unnecessary_return_variable/avoid_unnecessary_return_variable_rule.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; +import '../auto_test_lint_offsets.dart'; + void main() { defineReflectiveSuite(() { defineReflectiveTests(AvoidUnnecessaryReturnVariableTest); @@ -9,25 +11,23 @@ void main() { } @reflectiveTest -class AvoidUnnecessaryReturnVariableTest extends AnalysisRuleTest { +class AvoidUnnecessaryReturnVariableTest extends AnalysisRuleTest + with AutoTestLintOffsets { @override void setUp() { rule = AvoidUnnecessaryReturnVariableRule(); super.setUp(); } - @override - String get analysisRule => rule.name; - - void test_does_not_report_if_return_good_trivial() async { + Future test_does_not_report_if_return_good_trivial() async { await assertNoDiagnostics(r''' int returnVarTestTrivial() { return 1; } - '''); +'''); } - void test_does_not_report_if_return_is_mutable() async { + Future test_does_not_report_if_return_is_mutable() async { await assertNoDiagnostics(r''' int returnVarTestMutable() { var a = 1; @@ -35,18 +35,18 @@ int returnVarTestMutable() { return a; } - '''); +'''); } - void test_does_not_report_if_returns_parameter() async { + Future test_does_not_report_if_returns_parameter() async { await assertNoDiagnostics(r''' int returnVarTestReturnParameter(int param) { return param; } - '''); +'''); } - void test_does_not_report_if_return_is_cached_mutable() async { + Future test_does_not_report_if_return_is_cached_mutable() async { await assertNoDiagnostics(r''' int returnVarTestCachedMutable() { var a = 1; @@ -57,26 +57,24 @@ int returnVarTestCachedMutable() { } void _doNothing() {} - '''); +'''); } - void test_reports_if_return_follows_declaration() async { - await assertDiagnostics( - r''' + Future test_reports_if_return_follows_declaration() async { + await assertAutoDiagnostics(''' int returnVarTestReturnFollowsDeclaration() { var a = 1; final result = a; //Some comment here - return result; + ${expectLint('return result;')} } - ''', - [lint(105, 14)], - ); +'''); } - void test_does_not_report_if_return_is_cached_another_method_result() async { + Future + test_does_not_report_if_return_is_cached_another_method_result() async { await assertNoDiagnostics(r''' int returnVarTestCachedAnotherMethodResult() { var a = 1; @@ -94,7 +92,7 @@ void _doNothing() {} '''); } - void test_does_not_report_if_return_is_cached_object_field() async { + Future test_does_not_report_if_return_is_cached_object_field() async { await assertNoDiagnostics(r''' int returnVarTestCachedObjectField() { final obj = _TestClass(); @@ -116,7 +114,7 @@ void _doNothing() {} '''); } - void test_does_not_report_if_return_used_variable() async { + Future test_does_not_report_if_return_used_variable() async { await assertNoDiagnostics(r''' int returnVarTestUsedVariable() { var a = 1; @@ -128,22 +126,18 @@ int returnVarTestUsedVariable() { '''); } - void test_reports_if_return_is_bad_trivial() async { - await assertDiagnostics( - r''' + Future test_reports_if_return_is_bad_trivial() async { + await assertAutoDiagnostics(''' int returnVarTestBadTrivial() { final result = 1; - return result; + ${expectLint('return result;')} } -''', - [lint(55, 14)], - ); +'''); } - void test_reports_if_return_is_bad_immutable_expression() async { - await assertDiagnostics( - r''' + Future test_reports_if_return_is_bad_immutable_expression() async { + await assertAutoDiagnostics(''' int returnVarTestBadImmutableExpression() { const constLocal = 1; final finalLocal = 1; @@ -156,7 +150,7 @@ int returnVarTestBadImmutableExpression() { testObj.finalField; _doNothing(); - return result; + ${expectLint('return result;')} } class _TestClass { @@ -168,12 +162,10 @@ class _TestClass { } void _doNothing() {} -''', - [lint(304, 14)], - ); +'''); } - void test_does_not_report_if_return_is_cached_nested_block() async { + Future test_does_not_report_if_return_is_cached_nested_block() async { await assertNoDiagnostics(r''' Future testAvoidUnnecessaryReturnVariableNestedBlock() async { final cached = 'cached'; @@ -186,34 +178,30 @@ Future testAvoidUnnecessaryReturnVariableNestedBlock() async { '''); } - void test_reports_if_return_is_cached_and_only_returned_nested_block() async { - await assertDiagnostics( - r''' + Future + test_reports_if_return_is_cached_and_only_returned_nested_block() async { + await assertAutoDiagnostics(''' int test(bool b) { final a = 3; if (b) { - return a; + ${expectLint('return a;')} } return 0; } -''', - [lint(49, 9)], - ); +'''); } - void test_reports_if_return_in_parentheses() async { - await assertDiagnostics( - r''' + Future test_reports_if_return_in_parentheses() async { + await assertAutoDiagnostics(''' int test() { final a = 3; - return (a); + ${expectLint('return (a);')} } -''', - [lint(30, 11)], - ); +'''); } - void test_does_not_report_if_return_is_cached_and_used_after_return_nested_block() async { + Future + test_does_not_report_if_return_is_cached_and_used_after_return_nested_block() async { await assertNoDiagnostics(r''' int test(bool b) { final a = 3; @@ -225,4 +213,3 @@ int test(bool b) { '''); } } - diff --git a/test/lints/avoid_unnecessary_set_state/avoid_unnecessary_set_state_rule_test.dart b/test/lints/avoid_unnecessary_set_state/avoid_unnecessary_set_state_rule_test.dart index 0e160ae0..a7d308f0 100644 --- a/test/lints/avoid_unnecessary_set_state/avoid_unnecessary_set_state_rule_test.dart +++ b/test/lints/avoid_unnecessary_set_state/avoid_unnecessary_set_state_rule_test.dart @@ -25,6 +25,8 @@ import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; import 'package:solid_lints/src/lints/avoid_unnecessary_setstate/avoid_unnecessary_set_state_rule.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; +import '../auto_test_lint_offsets.dart'; + void main() { defineReflectiveSuite(() { defineReflectiveTests(AvoidUnnecessarySetStateRuleTest); @@ -32,14 +34,13 @@ void main() { } @reflectiveTest -class AvoidUnnecessarySetStateRuleTest extends AnalysisRuleTest { +class AvoidUnnecessarySetStateRuleTest extends AnalysisRuleTest + with AutoTestLintOffsets { @override void setUp() { final flutter = newPackage('flutter'); - flutter.addFile( - 'lib/src/widgets/framework.dart', - r''' + flutter.addFile('lib/src/widgets/framework.dart', r''' abstract class Widget {} abstract class StatefulWidget extends Widget {} @@ -66,19 +67,14 @@ class ElevatedButton extends Widget { ElevatedButton({this.onPressed, this.onLongPress, this.child}); } -''', - ); +'''); rule = AvoidUnnecessarySetStateRule(); super.setUp(); } - @override - String get analysisRule => rule.name; - - void test_reports_set_state_in_init_state() async { - await assertDiagnostics( - r''' + Future test_reports_set_state_in_init_state() async { + await assertAutoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; class _MyWidgetState extends State { @@ -88,9 +84,7 @@ class _MyWidgetState extends State { void initState() { super.initState(); - setState(() { - _myString = "Hello"; - }); + ${expectLint('setState(() {\n _myString = "Hello";\n })')}; } @override @@ -100,14 +94,11 @@ class _MyWidgetState extends State { ); } } - ''', - [lint(194, 47)], - ); +'''); } - void test_reports_set_state_in_init_state_with_condition() async { - await assertDiagnostics( - r''' + Future test_reports_set_state_in_init_state_with_condition() async { + await assertAutoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; class _MyWidgetState extends State { @@ -119,9 +110,7 @@ class _MyWidgetState extends State { super.initState(); if (_condition) { - setState(() { - _myString = "Hello"; - }); + ${expectLint('setState(() {\n _myString = "Hello";\n })')}; } } @@ -132,14 +121,11 @@ class _MyWidgetState extends State { ); } } - ''', - [lint(250, 51)], - ); +'''); } - void test_reports_set_state_in_init_state_through_method() async { - await assertDiagnostics( - r''' + Future test_reports_set_state_in_init_state_through_method() async { + await assertAutoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; class _MyWidgetState extends State { @@ -150,7 +136,7 @@ class _MyWidgetState extends State { void initState() { super.initState(); - myStateUpdateMethod(); + ${expectLint('myStateUpdateMethod()')}; } void myStateUpdateMethod() { @@ -166,14 +152,11 @@ class _MyWidgetState extends State { ); } } - ''', - [lint(226, 21)], - ); +'''); } - void test_reports_set_state_in_did_update_widget() async { - await assertDiagnostics( - r''' + Future test_reports_set_state_in_did_update_widget() async { + await assertAutoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; class _MyWidgetState extends State { @@ -182,9 +165,7 @@ class _MyWidgetState extends State { @override void didUpdateWidget(StatefulWidget oldWidget) { super.didUpdateWidget(oldWidget); - setState(() { - _myString = "Hello"; - }); + ${expectLint('setState(() {\n _myString = "Hello";\n })')}; } @override @@ -194,14 +175,11 @@ class _MyWidgetState extends State { ); } } - ''', - [lint(238, 47)], - ); +'''); } - void test_reports_set_state_in_build_method() async { - await assertDiagnostics( - r''' + Future test_reports_set_state_in_build_method() async { + await assertAutoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; class _MyWidgetState extends State { @@ -209,23 +187,18 @@ class _MyWidgetState extends State { @override Widget build(BuildContext context) { - setState(() { - _myString = "Hello"; - }); + ${expectLint('setState(() {\n _myString = "Hello";\n })')}; return ElevatedButton( child: Text(_myString), ); } } - ''', - [lint(188, 47)], - ); +'''); } - void test_reports_set_state_in_build_method_with_condition() async { - await assertDiagnostics( - r''' + Future test_reports_set_state_in_build_method_with_condition() async { + await assertAutoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; class _MyWidgetState extends State { @@ -235,9 +208,7 @@ class _MyWidgetState extends State { @override Widget build(BuildContext context) { if (_condition) { - setState(() { - _myString = "Hello"; - }); + ${expectLint('setState(() {\n _myString = "Hello";\n })')}; } return ElevatedButton( @@ -245,14 +216,11 @@ class _MyWidgetState extends State { ); } } - ''', - [lint(244, 51)], - ); +'''); } - void test_reports_set_state_in_build_method_through_method() async { - await assertDiagnostics( - r''' + Future test_reports_set_state_in_build_method_through_method() async { + await assertAutoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; class _MyWidgetState extends State { @@ -266,21 +234,18 @@ class _MyWidgetState extends State { @override Widget build(BuildContext context) { - myStateUpdateMethod(); + ${expectLint('myStateUpdateMethod()')}; return ElevatedButton( child: Text(_myString), ); } } - ''', - [lint(277, 21)], - ); +'''); } - void test_does_not_report_set_state_in_button_on_pressed() async { - await assertNoDiagnostics( - r''' + Future test_does_not_report_set_state_in_button_on_pressed() async { + await assertNoDiagnostics(r''' import 'package:flutter/src/widgets/framework.dart'; class _MyWidgetState extends State { @@ -300,13 +265,11 @@ class _MyWidgetState extends State { ); } } - ''', - ); +'''); } - void test_does_not_report_set_state_in_button_on_long_press() async { - await assertNoDiagnostics( - r''' + Future test_does_not_report_set_state_in_button_on_long_press() async { + await assertNoDiagnostics(r''' import 'package:flutter/src/widgets/framework.dart'; class _MyWidgetState extends State { @@ -324,7 +287,6 @@ class _MyWidgetState extends State { ); } } - ''', - ); +'''); } } diff --git a/test/lints/avoid_unnecessary_type_assertions/avoid_unnecessary_type_assertions_rule_test.dart b/test/lints/avoid_unnecessary_type_assertions/avoid_unnecessary_type_assertions_rule_test.dart index 602e60ba..a383bf07 100644 --- a/test/lints/avoid_unnecessary_type_assertions/avoid_unnecessary_type_assertions_rule_test.dart +++ b/test/lints/avoid_unnecessary_type_assertions/avoid_unnecessary_type_assertions_rule_test.dart @@ -19,9 +19,6 @@ class AvoidUnnecessaryTypeAssertionsRuleTest extends AnalysisRuleTest super.setUp(); } - @override - String get analysisRule => AvoidUnnecessaryTypeAssertionsRule.lintName; - Future test_does_not_report_if_is_expression_checks_nullable_source() async { await assertNoDiagnostics(r''' diff --git a/test/lints/avoid_unrelated_type_assertions/avoid_unrelated_type_assertions_rule_test.dart b/test/lints/avoid_unrelated_type_assertions/avoid_unrelated_type_assertions_rule_test.dart index a2260724..c41bb3ad 100644 --- a/test/lints/avoid_unrelated_type_assertions/avoid_unrelated_type_assertions_rule_test.dart +++ b/test/lints/avoid_unrelated_type_assertions/avoid_unrelated_type_assertions_rule_test.dart @@ -2,6 +2,8 @@ import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; import 'package:solid_lints/src/lints/avoid_unrelated_type_assertions/avoid_unrelated_type_assertions_rule.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; +import '../auto_test_lint_offsets.dart'; + void main() { defineReflectiveSuite(() { defineReflectiveTests(AvoidUnrelatedTypeAssertionsRuleTest); @@ -9,64 +11,46 @@ void main() { } @reflectiveTest -class AvoidUnrelatedTypeAssertionsRuleTest extends AnalysisRuleTest { +class AvoidUnrelatedTypeAssertionsRuleTest extends AnalysisRuleTest + with AutoTestLintOffsets { @override void setUp() { rule = AvoidUnrelatedTypeAssertionsRule(); super.setUp(); } - @override - String get analysisRule => rule.name; - - void test_reports_unrelated_string_is_int() async { - await assertDiagnostics( - r''' + Future test_reports_unrelated_string_is_int() async { + await assertAutoDiagnostics(''' void fun() { final testString = ''; - final result = testString is int; + final result = ${expectLint('testString is int', messageContainsAll: ['false'])}; } -''', - [ - lint(56, 17, messageContainsAll: ['false']), - ], - ); +'''); } - void test_reports_unrelated_int_list_is_string_list() async { - await assertDiagnostics( - r''' + Future test_reports_unrelated_int_list_is_string_list() async { + await assertAutoDiagnostics(''' void fun() { final testList = [1, 2, 3]; - final result = testList is List; + final result = ${expectLint('testList is List', messageContainsAll: ['false'])}; } -''', - [ - lint(61, 24, messageContainsAll: ['false']), - ], - ); +'''); } - void test_reports_unrelated_string_map_is_double_map() async { - await assertDiagnostics( - r''' + Future test_reports_unrelated_string_map_is_double_map() async { + await assertAutoDiagnostics(''' void fun() { final testMap = {'A': 'B'}; - final result = testMap['A'] is double; + final result = ${expectLint("testMap['A'] is double", messageContainsAll: ['false'])}; } -''', - [ - lint(61, 22, messageContainsAll: ['false']), - ], - ); +'''); } - void test_reports_unrelated_class_is_another_class() async { - await assertDiagnostics( - r''' + Future test_reports_unrelated_class_is_another_class() async { + await assertAutoDiagnostics(''' class Foo {} class Bar {} @@ -74,18 +58,13 @@ class Bar {} void fun() { final Foo foo = Foo(); - final result = foo is Bar; + final result = ${expectLint('foo is Bar', messageContainsAll: ['false'])}; } -''', - [ - lint(84, 10, messageContainsAll: ['false']), - ], - ); +'''); } - void test_reports_unrelated_child_class_is_another_class() async { - await assertDiagnostics( - r''' + Future test_reports_unrelated_child_class_is_another_class() async { + await assertAutoDiagnostics(''' class Foo {} class Bar {} @@ -95,18 +74,13 @@ class ChildFoo extends Foo {} void fun() { final childFoo = ChildFoo(); - final result = childFoo is Bar; + final result = ${expectLint('childFoo is Bar', messageContainsAll: ['false'])}; } -''', - [ - lint(121, 15, messageContainsAll: ['false']), - ], - ); +'''); } - void test_reports_unrelated_is_condition() async { - await assertDiagnostics( - r''' + Future test_reports_unrelated_is_condition() async { + await assertAutoDiagnostics(''' class _A {} class _B extends _A {} @@ -116,18 +90,13 @@ class _C {} void lint() { final _A a = _B(); - if (a is _C) return; + if (${expectLint('a is _C', messageContainsAll: ['false'])}) return; } -''', - [ - lint(92, 7, messageContainsAll: ['false']), - ], - ); +'''); } - void test_reports_unrelated_is_not_condition() async { - await assertDiagnostics( - r''' + Future test_reports_unrelated_is_not_condition() async { + await assertAutoDiagnostics(''' class _A {} class _B extends _A {} @@ -137,12 +106,8 @@ class _C {} void lint() { final _A a = _B(); - if (a is! _C) return; + if (${expectLint('a is! _C', messageContainsAll: ['true'])}) return; } -''', - [ - lint(92, 8, messageContainsAll: ['true']), - ], - ); +'''); } } diff --git a/test/lints/avoid_unused_parameters/avoid_unused_parameters_rule_test.dart b/test/lints/avoid_unused_parameters/avoid_unused_parameters_rule_test.dart index 440ee2e4..3ea643ce 100644 --- a/test/lints/avoid_unused_parameters/avoid_unused_parameters_rule_test.dart +++ b/test/lints/avoid_unused_parameters/avoid_unused_parameters_rule_test.dart @@ -3,6 +3,7 @@ import 'package:solid_lints/src/lints/avoid_unused_parameters/avoid_unused_param import 'package:test_reflective_loader/test_reflective_loader.dart'; import '../../utils/fake_analysis_options_loader.dart'; +import '../auto_test_lint_offsets.dart'; void main() { defineReflectiveSuite(() { @@ -11,7 +12,8 @@ void main() { } @reflectiveTest -class AvoidUnusedParametersRuleTest extends AnalysisRuleTest { +class AvoidUnusedParametersRuleTest extends AnalysisRuleTest + with AutoTestLintOffsets { static const _importFlutterMaterial = "import 'package:flutter/material.dart';"; @@ -62,90 +64,72 @@ class Placeholder extends StatelessWidget { } Future test_reports_on_unused_function_expression_parameters() async { - await assertDiagnostics( - r''' + await assertAutoDiagnostics(''' typedef MaxFun = int Function(int a, int b); -final MaxFun bad = (int a, int b) => 1; +final MaxFun bad = (${expectLint('int a')}, ${expectLint('int b')}) => 1; -final MaxFun tetsFun = (int a, int b) { +final MaxFun tetsFun = (${expectLint('int a')}, ${expectLint('int b')}) { return 4; }; -var c = (String g) { +var c = (${expectLint('String g')}) { return '0'; }; -final MaxFun maxFunInstance = (int a, int b) => 1; -''', - [ - lint(66, 5), - lint(73, 5), - lint(111, 5), - lint(118, 5), - lint(152, 8), - lint(213, 5), - lint(220, 5), - ], - ); +final MaxFun maxFunInstance = (${expectLint('int a')}, ${expectLint('int b')}) => 1; +'''); } Future test_reports_on_unused_optional_and_named_parameters() async { - await assertDiagnostics( - r''' -final optional = (int a, [int b = 0]) { + await assertAutoDiagnostics(''' +final optional = (int a, [${expectLint('int b = 0')}]) { return a; }; -final named = (int a, {required int b, int c = 0}) { +final named = (${expectLint('int a')}, {required int b, int c = 0}) { return c; }; -''', - [lint(26, 9), lint(71, 5)], - ); +'''); } Future test_reports_on_unused_top_level_functions() async { - await assertDiagnostics( - r''' -void fun(String s) { + await assertAutoDiagnostics(''' +void fun(${expectLint('String s')}) { return; } -void fun2(String s) { +void fun2(${expectLint('String s')}) { return; } -void closure(int a) { +void closure(${expectLint('int a')}) { void internal(int a) { print(a); } } -''', - [lint(9, 8), lint(44, 8), lint(82, 5)], - ); +'''); } Future test_reports_on_unused_parameters_in_methods() async { - await assertDiagnostics( - r''' + await assertAutoDiagnostics(''' class TestClass { - static void staticMethod(int a) {} + static void staticMethod(${expectLint('int a')}) {} - void method(String s) { + void method(${expectLint('String s')}) { return; } } class SomeOtherClass { - final MaxFun maxFunLint = (int a, int b) => 1; + final MaxFun maxFunLint = (${expectLint('int a')}, ${expectLint('int b')}) => 1; // Good final MaxFun good = (int a, int b) { return a * b; }; - void method(String s) { + void method(${expectLint('String s')}) { return; } } @@ -158,55 +142,42 @@ class SomeOtherAnotherClass { return; } - void anonymousCallback(Function(int a) cb) {} + void anonymousCallback(${expectLint('Function(int a) cb')}) {} } -''', - [ - lint(45, 5), - lint(70, 8), - lint(153, 5), - lint(160, 5), - lint(261, 8), - lint(450, 18), - ], - ); +'''); } Future test_reports_on_unused_parameters_in_constructors() async { - await assertDiagnostics( - r''' + await assertAutoDiagnostics(''' class Foo { final int a; final int? b; - Foo.another({required int c}) + Foo.another({${expectLint('required int c')}}) : a = 1, b = 0; - factory Foo.aOnly(int a) { + factory Foo.aOnly(${expectLint('int a')}) { return Foo._(1, null); } Foo._(this.a, this.b); } -''', - [lint(59, 14), lint(127, 5)], - ); +'''); } Future test_reports_on_unused_widget_constructor_parameters() async { - await assertDiagnostics( - ''' + await assertAutoDiagnostics(''' $_importFlutterMaterial class TestWidget extends StatelessWidget { const TestWidget({ super.key, - int a = 1, - String k = '', + ${expectLint('int a = 1')}, + ${expectLint("String k = ''")}, }); - factory TestWidget.a([int b = 0]) { + factory TestWidget.a([${expectLint('int b = 0')}]) { return const TestWidget(); } @@ -215,9 +186,7 @@ class TestWidget extends StatelessWidget { return const Placeholder(); } } -''', - [lint(124, 9), lint(139, 13), lint(185, 9)], - ); +'''); } Future test_does_not_report_on_used_parameters() async { @@ -364,21 +333,18 @@ class SimpleClassName { } Future test_reports_on_non_matching_excluded_declarations() async { - await assertDiagnostics( - r''' + await assertAutoDiagnostics(''' class Exclude { - void excludeMethod2(String s) { + void excludeMethod2(${expectLint('String s')}) { return; } } class SimpleClassName { - void simpleMethodName2(String s) { + void simpleMethodName2(${expectLint('String s')}) { return; } } -''', - [lint(38, 8), lint(118, 8)], - ); +'''); } } diff --git a/test/lints/double_literal_format/double_literal_format_rule_test.dart b/test/lints/double_literal_format/double_literal_format_rule_test.dart index d3c8c2a7..43e01e78 100644 --- a/test/lints/double_literal_format/double_literal_format_rule_test.dart +++ b/test/lints/double_literal_format/double_literal_format_rule_test.dart @@ -2,6 +2,8 @@ import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; import 'package:solid_lints/src/lints/double_literal_format/double_literal_format_rule.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; +import '../auto_test_lint_offsets.dart'; + void main() { defineReflectiveSuite(() { defineReflectiveTests(DoubleLiteralFormatRuleTest); @@ -9,7 +11,8 @@ void main() { } @reflectiveTest -class DoubleLiteralFormatRuleTest extends AnalysisRuleTest { +class DoubleLiteralFormatRuleTest extends AnalysisRuleTest + with AutoTestLintOffsets { @override void setUp() { rule = DoubleLiteralFormatRule(); @@ -17,99 +20,58 @@ class DoubleLiteralFormatRuleTest extends AnalysisRuleTest { } Future test_reports_on_leading_zeros() async { - await assertDiagnostics( - r''' -var badA = 05.23; -double badB = -01.2; -double badC = -001.2; -double badExpr = 5.23 + 05.23; + await assertAutoDiagnostics(''' +var badA = ${expectLint('05.23')}; +double badB = -${expectLint('01.2')}; +double badC = -${expectLint('001.2')}; +double badExpr = 5.23 + ${expectLint('05.23')}; class Test { - var badA = 05.23; - double badB = -01.2; - double badC = -001.2; - double badExpr = 5.23 + 05.23; + var badA = ${expectLint('05.23')}; + double badB = -${expectLint('01.2')}; + double badC = -${expectLint('001.2')}; + double badExpr = 5.23 + ${expectLint('05.23')}; } -''', - [ - lint(11, 5), - lint(33, 4), - lint(54, 5), - lint(85, 5), - - lint(119, 5), - lint(143, 4), - lint(166, 5), - lint(199, 5), - ], - ); +'''); } Future test_reports_on_trailing_zeros() async { - await assertDiagnostics( - r''' + await assertAutoDiagnostics(''' class Test { - var badA = 5.230; - final badB = -1.20; - double get badC => -1.200; - double badExpr = 5.23 + 5.230; - var badD = -0.400e-5; + var badA = ${expectLint('5.230')}; + final badB = -${expectLint('1.20')}; + double get badC => -${expectLint('1.200')}; + double badExpr = 5.23 + ${expectLint('5.230')}; + var badD = -${expectLint('0.400e-5')}; void someMethod() { - var badA = 5.230; - double badB = -1.20; - double badC = -1.200; - double badExpr = 5.23 + 5.230; - var badD = -0.400E-5; + var badA = ${expectLint('5.230')}; + double badB = -${expectLint('1.20')}; + double badC = -${expectLint('1.200')}; + double badExpr = 5.23 + ${expectLint('5.230')}; + var badD = -${expectLint('0.400E-5')}; } } -''', - [ - lint(26, 5), - lint(49, 4), - lint(77, 5), - lint(110, 5), - lint(131, 8), - - lint(179, 5), - lint(205, 4), - lint(230, 5), - lint(265, 5), - lint(288, 8), - ], - ); +'''); } Future test_reports_on_leading_decimal_point() async { - await assertDiagnostics( - r''' -var badA = .23; -double badB = -.2; -double badExpr = 5.23 + .23; -var badD = .4e-5; + await assertAutoDiagnostics(''' +var badA = ${expectLint('.23')}; +double badB = -${expectLint('.2')}; +double badExpr = 5.23 + ${expectLint('.23')}; +var badD = ${expectLint('.4e-5')}; class Test { - var badA = .23; - double badB = -.2; - double get badExpr => 5.23 + .23; - double get badD => -.4E-5; + var badA = ${expectLint('.23')}; + double badB = -${expectLint('.2')}; + double get badExpr => 5.23 + ${expectLint('.23')}; + double get badD => -${expectLint('.4E-5')}; } -''', - [ - lint(11, 3), - lint(31, 2), - lint(59, 3), - lint(75, 5), - - lint(109, 3), - lint(131, 2), - lint(166, 3), - lint(193, 5), - ], - ); +'''); } - void test_does_not_report_on_non_double_literals() async { + Future test_does_not_report_on_non_double_literals() async { await assertNoDiagnostics(r''' var badA = '05.23'; var stringA = '5.23'; diff --git a/test/lints/newline_before_return/newline_before_return_rule_test.dart b/test/lints/newline_before_return/newline_before_return_rule_test.dart index db805301..a8ea4f19 100644 --- a/test/lints/newline_before_return/newline_before_return_rule_test.dart +++ b/test/lints/newline_before_return/newline_before_return_rule_test.dart @@ -2,6 +2,8 @@ import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; import 'package:solid_lints/src/lints/newline_before_return/newline_before_return_rule.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; +import '../auto_test_lint_offsets.dart'; + void main() { defineReflectiveSuite(() { defineReflectiveTests(NewlineBeforeReturnRuleTest); @@ -9,68 +11,55 @@ void main() { } @reflectiveTest -class NewlineBeforeReturnRuleTest extends AnalysisRuleTest { +class NewlineBeforeReturnRuleTest extends AnalysisRuleTest + with AutoTestLintOffsets { @override void setUp() { rule = NewlineBeforeReturnRule(); super.setUp(); } - @override - String get analysisRule => rule.name; - - void test_reports_no_newline_before_return_value() async { - await assertDiagnostics( - r''' + Future test_reports_no_newline_before_return_value() async { + await assertAutoDiagnostics(''' int method() { final a = 0; - return 1; + ${expectLint('return 1;')} } - ''', - [lint(32, 9)], - ); +'''); } - void test_reports_no_newline_before_return() async { - await assertDiagnostics( - r''' + Future test_reports_no_newline_before_return() async { + await assertAutoDiagnostics(''' void method() { final a = 0; - return; + ${expectLint('return;')} } - ''', - [lint(33, 7)], - ); +'''); } - void test_reports_no_newline_before_return_with_comment() async { - await assertDiagnostics( - r''' + Future test_reports_no_newline_before_return_with_comment() async { + await assertAutoDiagnostics(''' void method() { final a = 0; // Comment - return; + ${expectLint('return;')} } - ''', - [lint(46, 7)], - ); +'''); } - void test_reports_no_newline_before_return_with_multiple_comments() async { - await assertDiagnostics( - r''' + Future + test_reports_no_newline_before_return_with_multiple_comments() async { + await assertAutoDiagnostics(''' void method() { final a = 0; // Comment 1 // Comment 2 - return; + ${expectLint('return;')} } - ''', - [lint(63, 7)], - ); +'''); } - void test_does_not_report_newline_before_return_with_comment() async { + Future test_does_not_report_newline_before_return_with_comment() async { await assertNoDiagnostics(r''' void method() { final a = 0; @@ -78,40 +67,41 @@ void method() { // Comment return; } - '''); +'''); } - void test_does_not_report_no_newline_before_single_statement_return() async { + Future + test_does_not_report_no_newline_before_single_statement_return() async { await assertNoDiagnostics(r''' void method() { return; } - '''); +'''); } - void test_does_not_report_newline_before_return() async { + Future test_does_not_report_newline_before_return() async { await assertNoDiagnostics(r''' void method() { final a = 0; return; } - '''); +'''); } - void + Future test_does_not_report_no_newline_before_single_statement_return_value() async { await assertNoDiagnostics(r''' int method() { return 1; } - '''); +'''); } - void + Future test_does_not_report_no_newline_before_single_statement_nested_return() async { await assertNoDiagnostics(r''' -class Foo{ +class Foo { void bar(void Function()) { return; } @@ -123,13 +113,12 @@ void fun() { return; }); } - '''); +'''); } - void test_reports_no_newline_before_return_nested() async { - await assertDiagnostics( - r''' -class Foo{ + Future test_reports_no_newline_before_return_nested() async { + await assertAutoDiagnostics(''' +class Foo { void bar(void Function()) { return; } @@ -139,18 +128,15 @@ void fun() { final foo = Foo(); foo.bar(() { final a = 1; - return; + ${expectLint('return;')} }); } - ''', - [lint(130, 7)], - ); +'''); } - void test_reports_no_newline_before_two_return_nested() async { - await assertDiagnostics( - r''' -class Foo{ + Future test_reports_no_newline_before_two_return_nested() async { + await assertAutoDiagnostics(''' +class Foo { void bar(void Function()) { return; } @@ -160,12 +146,10 @@ void fun() { final foo = Foo(); foo.bar(() { final a = 1; - return; + ${expectLint('return;')} }); - return; + ${expectLint('return;')} } - ''', - [lint(130, 7), lint(146, 7)], - ); +'''); } } diff --git a/test/lints/no_equal_then_else/no_equal_then_else_rule_test.dart b/test/lints/no_equal_then_else/no_equal_then_else_rule_test.dart index 8eecbb3f..99059d62 100644 --- a/test/lints/no_equal_then_else/no_equal_then_else_rule_test.dart +++ b/test/lints/no_equal_then_else/no_equal_then_else_rule_test.dart @@ -2,6 +2,8 @@ import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; import 'package:solid_lints/src/lints/no_equal_then_else/no_equal_then_else_rule.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; +import '../auto_test_lint_offsets.dart'; + void main() { defineReflectiveSuite(() { defineReflectiveTests(NoEqualThenElseRuleTest); @@ -9,37 +11,32 @@ void main() { } @reflectiveTest -class NoEqualThenElseRuleTest extends AnalysisRuleTest { +class NoEqualThenElseRuleTest extends AnalysisRuleTest + with AutoTestLintOffsets { @override void setUp() { rule = NoEqualThenElseRule(); super.setUp(); } - @override - String get analysisRule => rule.name; - - void test_reports_then_and_else_equal() async { - await assertDiagnostics( - r''' + Future test_reports_then_and_else_equal() async { + await assertAutoDiagnostics(''' void fun() { final _valueA = 1; final _valueB = 2; int _result = 0; - if (_valueA == 1) { + ${expectLint('''if (_valueA == 1) { _result = _valueA; } else { _result = _valueA; - } + }''')} } -''', - [lint(78, 80)], - ); +'''); } - void test_does_not_report_then_and_else_different() async { + Future test_does_not_report_then_and_else_different() async { await assertNoDiagnostics(r''' void fun() { final _valueA = 1; @@ -56,23 +53,20 @@ void fun() { '''); } - void test_reports_conditional_expression_then_and_else_equal() async { - await assertDiagnostics( - r''' + Future test_reports_conditional_expression_then_and_else_equal() async { + await assertAutoDiagnostics(''' void fun() { final _valueA = 1; final _valueB = 2; int _result = 0; - _result = _valueA == 2 ? _valueA : _valueA; + _result = ${expectLint('_valueA == 2 ? _valueA : _valueA')}; } -''', - [lint(88, 32)], - ); +'''); } - void + Future test_does_not_report_conditional_expression_then_and_else_different() async { await assertNoDiagnostics(r''' void fun() { diff --git a/test/lints/prefer_early_return/prefer_early_return_rule_test.dart b/test/lints/prefer_early_return/prefer_early_return_rule_test.dart index 2e52493a..4b3cfa2e 100644 --- a/test/lints/prefer_early_return/prefer_early_return_rule_test.dart +++ b/test/lints/prefer_early_return/prefer_early_return_rule_test.dart @@ -2,6 +2,8 @@ import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; import 'package:solid_lints/src/lints/prefer_early_return/prefer_early_return_rule.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; +import '../auto_test_lint_offsets.dart'; + void main() { defineReflectiveSuite(() { defineReflectiveTests(PreferEarlyReturnRuleTest); @@ -9,47 +11,38 @@ void main() { } @reflectiveTest -class PreferEarlyReturnRuleTest extends AnalysisRuleTest { +class PreferEarlyReturnRuleTest extends AnalysisRuleTest + with AutoTestLintOffsets { @override void setUp() { rule = PreferEarlyReturnRule(); super.setUp(); } - @override - String get analysisRule => PreferEarlyReturnRule.lintName; - - void test_reports_if_as_only_statement_in_function() async { - await assertDiagnostics( - r''' + Future test_reports_if_as_only_statement_in_function() async { + await assertAutoDiagnostics(''' void test(bool a) { - if (a) { + ${expectLint('''if (a) { print('hello'); - } + }''')} } -''', - [lint(22, 32)], - ); +'''); } - void test_reports_if_with_return() async { - await assertDiagnostics( - r''' + Future test_reports_if_with_return() async { + await assertAutoDiagnostics(''' void test(bool a) { - if (a) { + ${expectLint('''if (a) { print('hello'); - } + }''')} return; } -''', - [lint(22, 32)], - ); +'''); } - void test_does_not_report_if_with_return_value() async { - await assertNoDiagnostics( - r''' + Future test_does_not_report_if_with_return_value() async { + await assertNoDiagnostics(r''' int test(bool a) { if (a) { print('hello'); @@ -57,30 +50,23 @@ int test(bool a) { return 1; } -''', - ); +'''); } - void test_reports_nested_if_as_only_statement() async { - await assertDiagnostics( - r''' + Future test_reports_nested_if_as_only_statement() async { + await assertAutoDiagnostics(''' void test(bool a, bool b) { - if (a) { + ${expectLint('''if (a) { if (b) { print('nested'); } - } + }''')} } -''', - [ - lint(30, 54), - ], - ); +'''); } - void test_does_not_report_nested_if_with_return_value() async { - await assertNoDiagnostics( - r''' + Future test_does_not_report_nested_if_with_return_value() async { + await assertNoDiagnostics(r''' int test(bool a, bool b) { if (a) { if (b) { @@ -90,52 +76,40 @@ int test(bool a, bool b) { return 1; } -''', - ); +'''); } - void test_reports_nested_3_if_as_only_statement() async { - await assertDiagnostics( - r''' + Future test_reports_nested_3_if_as_only_statement() async { + await assertAutoDiagnostics(''' void test(bool a, bool b, bool c) { - if (a) { + ${expectLint('''if (a) { if (b) { if (c){ print('nested'); } } - } + }''')} } -''', - [ - lint(38, 78), - ], - ); +'''); } - void test_reports_nested_3_with_return() async { - await assertDiagnostics( - r''' + Future test_reports_nested_3_with_return() async { + await assertAutoDiagnostics(''' void test(bool a, bool b, bool c) { - if (a) { + ${expectLint('''if (a) { if (b) { if (c){ print('nested'); } } - } + }''')} return; } -''', - [ - lint(38, 78), - ], - ); +'''); } - void test_does_not_report_if_else() async { - await assertNoDiagnostics( - r''' + Future test_does_not_report_if_else() async { + await assertNoDiagnostics(r''' void test(bool a) { if (a) { print('hello'); @@ -143,13 +117,11 @@ void test(bool a) { print('hello'); } } -''', - ); +'''); } - void test_does_not_report_if_else_return() async { - await assertNoDiagnostics( - r''' + Future test_does_not_report_if_else_return() async { + await assertNoDiagnostics(r''' void test(bool a) { if (a) { print('hello'); @@ -157,13 +129,11 @@ void test(bool a) { return; } } -''', - ); +'''); } - void test_does_not_report_nested_if_else() async { - await assertNoDiagnostics( - r''' + Future test_does_not_report_nested_if_else() async { + await assertNoDiagnostics(r''' void test(bool a, bool b) { if (a) { if(b){ @@ -173,49 +143,39 @@ void test(bool a, bool b) { print('hello'); } } -''', - ); +'''); } - void test_reports_inner_if_else() async { - await assertDiagnostics( - r''' + Future test_reports_inner_if_else() async { + await assertAutoDiagnostics(''' void test(bool a, bool b) { - if (a) { + ${expectLint('''if (a) { if(b){ print('hello'); } else { print('hello'); } - } + }''')} } -''', - [ - lint(30, 90), - ], - ); +'''); } - void test_reports_on_three_if() async { - await assertDiagnostics( - r''' + Future test_reports_on_three_if() async { + await assertAutoDiagnostics(''' void threeIf(bool a, bool b, bool c) { - if (a) { + ${expectLint('''if (a) { if (b) { if (c) { print('hello'); } } - } -}''', - [lint(41, 74)], - ); + }''')} +}'''); } - void test_does_not_report_nested_3_with_else_1() async { - await assertNoDiagnostics( - r''' + Future test_does_not_report_nested_3_with_else_1() async { + await assertNoDiagnostics(r''' void test(bool a, bool b, bool c) { if (a) { if (b) { @@ -227,15 +187,13 @@ void test(bool a, bool b, bool c) { print('hello'); } } -''', - ); +'''); } - void test_reports_nested_3_with_else_2() async { - await assertDiagnostics( - r''' + Future test_reports_nested_3_with_else_2() async { + await assertAutoDiagnostics(''' void test(bool a, bool b, bool c) { - if (a) { + ${expectLint('''if (a) { if (b) { if (c) { print('nested'); @@ -243,20 +201,15 @@ void test(bool a, bool b, bool c) { } else { print('nested'); } - } + }''')} } -''', - [ - lint(38, 115), - ], - ); +'''); } - void test_reports_nested_3_with_else_3() async { - await assertDiagnostics( - r''' + Future test_reports_nested_3_with_else_3() async { + await assertAutoDiagnostics(''' void test(bool a, bool b, bool c) { - if (a) { + ${expectLint('''if (a) { if (b) { if (c) { print('nested'); @@ -265,65 +218,49 @@ void test(bool a, bool b, bool c) { print('nested'); } } - } + }''')} } -''', - [ - lint(38, 126), - ], - ); +'''); } - void test_reports_2_sequencial_if() async { - await assertDiagnostics( - r''' + Future test_reports_2_sequencial_if() async { + await assertAutoDiagnostics(''' void test(bool a, bool b) { if (a) return; - if (b) { + ${expectLint('''if (b) { print('gello'); - } + }''')} } -''', - [ - lint(47, 32), - ], - ); +'''); } - void test_does_not_report_2_sequencial_if_with_return() async { - await assertNoDiagnostics( - r''' + Future test_does_not_report_2_sequencial_if_with_return() async { + await assertNoDiagnostics(r''' void test(bool a, bool b) { if (a) return; if (b) return; return; } -''', - ); +'''); } - void test_reports_2_sequencial_if_with_return_2() async { - await assertDiagnostics( - r''' + Future test_reports_2_sequencial_if_with_return_2() async { + await assertAutoDiagnostics(''' void test(bool a, bool b) { if (a) return; - if (b) { + ${expectLint('''if (b) { print('hello'); - } + }''')} return; } -''', - [ - lint(47, 32), - ], - ); +'''); } - void test_does_not_report_2_sequencial_with_following_statement() async { - await assertNoDiagnostics( - r''' + Future + test_does_not_report_2_sequencial_with_following_statement() async { + await assertNoDiagnostics(r''' void test(bool a, bool b) { if (a) return; if (b) { @@ -332,69 +269,52 @@ void test(bool a, bool b) { print('after'); } -''', - ); +'''); } - void test_reports_2_sequencial_if_with_something() async { - await assertDiagnostics( - r''' + Future test_reports_2_sequencial_if_with_something() async { + await assertAutoDiagnostics(''' void test(bool a, bool b) { if (a) { print('hello'); } - if (b) { + ${expectLint('''if (b) { print('hello'); - } + }''')} } -''', - [ - lint(65, 32), - ], - ); +'''); } - void test_reports_3_sequencial_if_with_return() async { - await assertDiagnostics( - r''' + Future test_reports_3_sequencial_if_with_return() async { + await assertAutoDiagnostics(''' void test(bool a, bool b, bool c) { if (a) return; if (b) return; - if (c) { + ${expectLint('''if (c) { print('hello'); - } + }''')} return; } -''', - [ - lint(72, 32), - ], - ); +'''); } - void test_reports_3_sequencial_if_with_something_2() async { - await assertDiagnostics( - r''' + Future test_reports_3_sequencial_if_with_something_2() async { + await assertAutoDiagnostics(''' void test(bool a, bool b, bool c) { if (a) return; if (b) { print('hello'); } - if (c) { + ${expectLint('''if (c) { print('hello'); - } + }''')} } -''', - [ - lint(90, 32), - ], - ); +'''); } - void test_does_not_report_if_throw_with_return() async { - await assertNoDiagnostics( - r''' + Future test_does_not_report_if_throw_with_return() async { + await assertNoDiagnostics(r''' void test(bool a) { if (a) { throw ''; @@ -402,13 +322,11 @@ void test(bool a) { return; } -''', - ); +'''); } - void test_does_not_report_if_else_throw() async { - await assertNoDiagnostics( - r''' + Future test_does_not_report_if_else_throw() async { + await assertNoDiagnostics(r''' void test(bool a) { if (a) { print('hello'); @@ -416,79 +334,58 @@ void test(bool a) { throw ''; } } -''', - ); +'''); } - void test_reports_2_sequencial_if_throw() async { - await assertDiagnostics( - r''' + Future test_reports_2_sequencial_if_throw() async { + await assertAutoDiagnostics(''' void test(bool a, bool b) { if (a) throw ''; - if (b) { + ${expectLint('''if (b) { print('hello'); - } + }''')} } -''', - [ - lint(49, 32), - ], - ); +'''); } - void test_reports_2_sequencial_if_throw_with_return() async { - await assertDiagnostics( - r''' + Future test_reports_2_sequencial_if_throw_with_return() async { + await assertAutoDiagnostics(''' void test(bool a, bool b) { if (a) throw ''; - if (b) { + ${expectLint('''if (b) { print('hello'); - } + }''')} return; } -''', - [ - lint(49, 32), - ], - ); +'''); } - void test_reports_3_sequencial_if_throw_with_return() async { - await assertDiagnostics( - r''' + Future test_reports_3_sequencial_if_throw_with_return() async { + await assertAutoDiagnostics(''' void test(bool a, bool b, bool c) { if (a) throw ''; if (b) throw ''; - if (c) { + ${expectLint('''if (c) { print('hello'); - } + }''')} return; } -''', - [ - lint(76, 32), - ], - ); +'''); } - void test_reports_3_sequencial_if_throw_with_something() async { - await assertDiagnostics( - r''' + Future test_reports_3_sequencial_if_throw_with_something() async { + await assertAutoDiagnostics(''' void test(bool a, bool b, bool c) { if (a) throw ''; if (b) { print('hello'); } - if (c) { + ${expectLint('''if (c) { print('hello'); - } + }''')} } -''', - [ - lint(92, 32), - ], - ); +'''); } } diff --git a/test/lints/proper_super_calls/proper_super_calls_rule_test.dart b/test/lints/proper_super_calls/proper_super_calls_rule_test.dart index c043945c..6d73d246 100644 --- a/test/lints/proper_super_calls/proper_super_calls_rule_test.dart +++ b/test/lints/proper_super_calls/proper_super_calls_rule_test.dart @@ -2,6 +2,8 @@ import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; import 'package:solid_lints/src/lints/proper_super_calls/proper_super_calls_rule.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; +import '../auto_test_lint_offsets.dart'; + void main() { defineReflectiveSuite(() { defineReflectiveTests(ProperSuperCallsRuleTest); @@ -9,132 +11,108 @@ void main() { } @reflectiveTest -class ProperSuperCallsRuleTest extends AnalysisRuleTest { +class ProperSuperCallsRuleTest extends AnalysisRuleTest + with AutoTestLintOffsets { @override void setUp() { final flutter = newPackage('flutter'); - flutter.addFile( - 'lib/src/widgets/framework.dart', - r''' + flutter.addFile('lib/src/widgets/framework.dart', r''' abstract class StatefulWidget {} abstract class State { void initState() {} void dispose() {} } -''', - ); +'''); rule = ProperSuperCallsRule(); super.setUp(); } - @override - String get analysisRule => ProperSuperCallsRule.lintName; - - void test_initState_reports_when_super_not_first() async { - await assertDiagnostics( - r''' + Future test_initState_reports_when_super_not_first() async { + await assertAutoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; class MyWidgetState extends State { @override - void initState() { + void ${expectLint('initState')}() { print('Bad'); super.initState(); } } -''', - [lint(125, 9)], - ); +'''); } - void test_dispose_reports_when_super_not_last() async { - await assertDiagnostics( - r''' + Future test_dispose_reports_when_super_not_last() async { + await assertAutoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; class MyWidgetState extends State { @override - void dispose() { + void ${expectLint('dispose')}() { super.dispose(); print('Bad'); } } -''', - [lint(125, 7)], - ); +'''); } - void test_reports_even_without_explicit_override_annotation() async { - await assertDiagnostics( - r''' + Future test_reports_even_without_explicit_override_annotation() async { + await assertAutoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; class MyWidgetState extends State { - void initState() { + void ${expectLint('initState')}() { print('Bad'); super.initState(); } } -''', - [lint(113, 9)], - ); +'''); } - void test_reports_empty_body_missing_super() async { - await assertDiagnostics( - r''' + Future test_reports_empty_body_missing_super() async { + await assertAutoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; class MyWidgetState extends State { @override - void initState() {} + void ${expectLint('initState')}() {} } -''', - [lint(125, 9)], - ); +'''); } - void test_reports_when_wrong_super_method_is_called() async { - await assertDiagnostics( - r''' + Future test_reports_when_wrong_super_method_is_called() async { + await assertAutoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; class MyWidgetState extends State { @override - void initState() { + void ${expectLint('initState')}() { super.dispose(); print('Bad'); } } -''', - [lint(125, 9)], - ); +'''); } - void test_reports_in_deep_inheritance() async { - await assertDiagnostics( - r''' + Future test_reports_in_deep_inheritance() async { + await assertAutoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; abstract class BaseState extends State {} class MyWidgetState extends BaseState { @override - void dispose() { + void ${expectLint('dispose')}() { super.dispose(); print('Bad'); } } -''', - [lint(172, 7)], - ); +'''); } - void test_no_report_for_correct_usage() async { - await assertNoDiagnostics( - r''' + Future test_no_report_for_correct_usage() async { + await assertNoDiagnostics(r''' import 'package:flutter/src/widgets/framework.dart'; class MyWidgetState extends State { @@ -150,13 +128,11 @@ class MyWidgetState extends State { super.dispose(); } } -''', - ); +'''); } - void test_no_report_for_other_methods() async { - await assertNoDiagnostics( - r''' + Future test_no_report_for_other_methods() async { + await assertNoDiagnostics(r''' import 'package:flutter/src/widgets/framework.dart'; class MyWidgetState extends State { @@ -164,13 +140,11 @@ class MyWidgetState extends State { super.initState(); } } -''', - ); +'''); } - void test_no_report_for_async_correct_usage() async { - await assertNoDiagnostics( - r''' + Future test_no_report_for_async_correct_usage() async { + await assertNoDiagnostics(r''' import 'package:flutter/src/widgets/framework.dart'; class MyWidgetState extends State { @@ -188,13 +162,12 @@ class MyWidgetState extends State { await super.dispose(); } } -''', - ); +'''); } - void test_no_report_for_parenthesized_and_async_correct_usage() async { - await assertNoDiagnostics( - r''' + Future + test_no_report_for_parenthesized_and_async_correct_usage() async { + await assertNoDiagnostics(r''' import 'package:flutter/src/widgets/framework.dart'; class MyWidgetState extends State { @@ -212,7 +185,6 @@ class MyWidgetState extends State { (await super.dispose()); } } -''', - ); +'''); } } diff --git a/test/src/lints/avoid_final_with_getter/avoid_final_with_getter_rule_test.dart b/test/src/lints/avoid_final_with_getter/avoid_final_with_getter_rule_test.dart index 2149a1c0..af66db59 100644 --- a/test/src/lints/avoid_final_with_getter/avoid_final_with_getter_rule_test.dart +++ b/test/src/lints/avoid_final_with_getter/avoid_final_with_getter_rule_test.dart @@ -2,6 +2,8 @@ import 'package:analyzer_testing/analysis_rule/analysis_rule.dart'; import 'package:solid_lints/src/lints/avoid_final_with_getter/avoid_final_with_getter_rule.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; +import '../../../lints/auto_test_lint_offsets.dart'; + void main() { defineReflectiveSuite(() { defineReflectiveTests(AvoidFinalWithGetterRuleTest); @@ -9,7 +11,8 @@ void main() { } @reflectiveTest -class AvoidFinalWithGetterRuleTest extends AnalysisRuleTest { +class AvoidFinalWithGetterRuleTest extends AnalysisRuleTest + with AutoTestLintOffsets { @override void setUp() { rule = AvoidFinalWithGetterRule(); @@ -17,71 +20,56 @@ class AvoidFinalWithGetterRuleTest extends AnalysisRuleTest { } Future test_reports_on_getter_with_same_name_as_field() async { - await assertDiagnostics( - r''' + await assertAutoDiagnostics(''' class Test { final int _myField = 0; - int get myField => _myField; + ${expectLint('int get myField => _myField;')} } -''', - [lint(44, 28)], - ); +'''); } Future test_reports_on_getter_with_different_name_from_field() async { - await assertDiagnostics( - r''' + await assertAutoDiagnostics(''' class Test { final int _myField = 0; - int get myFieldInt => _myField; + ${expectLint('int get myFieldInt => _myField;')} } -''', - [lint(44, 31)], - ); +'''); } Future test_reports_on_static_getter_with_private_field() async { - await assertDiagnostics( - r''' + await assertAutoDiagnostics(''' class Test { static final int _myField = 0; - static int get myField => _myField; + ${expectLint('static int get myField => _myField;')} } -''', - [lint(51, 35)], - ); +'''); } Future test_reports_on_getter_with_this_property_access() async { - await assertDiagnostics( - r''' + await assertAutoDiagnostics(''' class Test { final int _myField = 0; - int get myField => this._myField; + ${expectLint('int get myField => this._myField;')} } -''', - [lint(44, 33)], - ); +'''); } Future test_reports_on_block_body_getter_returning_private_field() async { - await assertDiagnostics( - r''' + await assertAutoDiagnostics(''' class Test { final int _myField = 0; - int get myField { + ${expectLint('''int get myField { return _myField; - } + }''')} } -''', - [lint(44, 42)], - ); +'''); } Future test_does_not_report_on_getter_that_contains_logic() async { diff --git a/test/src/lints/avoid_returning_widgets/avoid_returning_widgets_rule_test.dart b/test/src/lints/avoid_returning_widgets/avoid_returning_widgets_rule_test.dart index b5286057..dba8fd06 100644 --- a/test/src/lints/avoid_returning_widgets/avoid_returning_widgets_rule_test.dart +++ b/test/src/lints/avoid_returning_widgets/avoid_returning_widgets_rule_test.dart @@ -4,6 +4,8 @@ import 'package:solid_lints/src/common/parameter_parser/analysis_options_loader. import 'package:solid_lints/src/lints/avoid_returning_widgets/avoid_returning_widgets_rule.dart'; import 'package:test_reflective_loader/test_reflective_loader.dart'; +import '../../../lints/auto_test_lint_offsets.dart'; + void main() { defineReflectiveSuite(() { defineReflectiveTests(AvoidReturningWidgetsRuleTest); @@ -11,7 +13,8 @@ void main() { } @reflectiveTest -class AvoidReturningWidgetsRuleTest extends AnalysisRuleTest { +class AvoidReturningWidgetsRuleTest extends AnalysisRuleTest + with AutoTestLintOffsets { static const _importFlutterWidgets = "import 'package:flutter/widgets.dart';"; static const _mockFlutterWidgetsContent = ''' abstract class Widget { @@ -115,76 +118,66 @@ $_mockAnalysisOptionsContent''', } Future test_reports_on_static_function() async { - await assertDiagnostics( - ''' + await assertAutoDiagnostics(''' $_importFlutterWidgets -Widget avoidReturningWidgets() => const SizedBox(); +${expectLint('Widget avoidReturningWidgets() => const SizedBox();')} -Widget build() { +${expectLint('''Widget build() { return SizedBox(); -} -''', - [lint(40, 51), lint(93, 39)], - ); +}''')} +'''); } Future test_reports_on_methods() async { - await assertDiagnostics( - ''' + await assertAutoDiagnostics(''' $_importFlutterWidgets class BaseWidget extends StatelessWidget { const BaseWidget({super.key}); - Widget decoratedBox() { + ${expectLint('''Widget decoratedBox() { return DecoratedBox(decoration: BoxDecoration()); - } + }''')} } -''', - [lint(119, 81)], - ); +'''); } Future test_reports_on_getters_but_not_setters() async { - await assertDiagnostics( - ''' + await assertAutoDiagnostics(''' $_importFlutterWidgets class BaseWidget extends StatelessWidget { const BaseWidget({super.key}); - Widget get box => SizedBox(); + ${expectLint('Widget get box => SizedBox();')} set box(Widget value) { throw 'unimplemented'; } } -''', - [lint(119, 29)], - ); +'''); } Future test_reports_on_private_members() async { _addBaseWidgetFile(); - await assertDiagnostics( - ''' + await assertAutoDiagnostics(''' $_importFlutterWidgets import 'base_widget.dart'; class MyWidget extends BaseWidget { const MyWidget({super.key}); - Widget _test1() => const SizedBox(); + ${expectLint('Widget _test1() => const SizedBox();')} - Widget _test2() { + ${expectLint('''Widget _test2() { return const SizedBox( child: SizedBox(), ); - } + }''')} - Widget get _test3 => const SizedBox(); + ${expectLint('Widget get _test3 => const SizedBox();')} @override Widget decoratedBox() { @@ -199,21 +192,14 @@ class MyWidget extends BaseWidget { return const SizedBox(); } } -''', - [ - lint(137, 36), - lint(177, 80), - lint(261, 38), - ], - ); +'''); } Future test_does_not_report_on_overridden_members() async { _addBaseWidgetFile(); // Shouldn't report even if not annotated with @override - await assertNoDiagnostics( - ''' + await assertNoDiagnostics(''' $_importFlutterWidgets import 'base_widget.dart'; @@ -230,13 +216,11 @@ class MyWidget extends BaseWidget { return const SizedBox(); } } -''', - ); +'''); } Future test_does_not_report_on_excluded() async { - await assertNoDiagnostics( - ''' + await assertNoDiagnostics(''' $_importFlutterWidgets SizedBox excludeMethod() => const SizedBox(); @@ -251,14 +235,11 @@ class ExcludeWidget extends StatelessWidget { Widget excludeWidgetMethod() => const SizedBox(); } - -''', - ); +'''); } Future test_reports_on_non_matching_excluded() async { - await assertDiagnostics( - ''' + await assertAutoDiagnostics(''' $_importFlutterWidgets SizedBox excludeMethod() => const SizedBox(); @@ -271,7 +252,7 @@ class ExcludeWidget extends StatelessWidget { return const Placeholder(); } - Widget notExcludeWidgetMethod() => const Placeholder(); + ${expectLint('Widget notExcludeWidgetMethod() => const Placeholder();')} } class NotExcludeWidget extends StatelessWidget { @@ -282,13 +263,8 @@ class NotExcludeWidget extends StatelessWidget { return const Placeholder(); } - Widget excludeWidgetMethod() => const SizedBox(); + ${expectLint('Widget excludeWidgetMethod() => const SizedBox();')} } -''', - [ - lint(260, 55), - lint(498, 49), - ], - ); +'''); } } diff --git a/test/src/lints/cyclomatic_complexity/cyclomatic_complexity_rule_test.dart b/test/src/lints/cyclomatic_complexity/cyclomatic_complexity_rule_test.dart index 4226997d..4b5c09c1 100644 --- a/test/src/lints/cyclomatic_complexity/cyclomatic_complexity_rule_test.dart +++ b/test/src/lints/cyclomatic_complexity/cyclomatic_complexity_rule_test.dart @@ -43,9 +43,6 @@ $_mockAnalysisOptionsContent''', ); } - @override - String get analysisRule => CyclomaticComplexityRule.lintName; - Future test_reports_when_complexity_exceeds_threshold() async { await assertAutoDiagnostics(''' void cyclomaticComplexity() ${expectLint(r'''{ @@ -281,7 +278,6 @@ void test(List l1, List l2, List l3, List l4) ${expectLint(r '''); } - Future test_reports_when_complexity_exceeds_threshold_due_to_logical_and_pattern() async { await assertAutoDiagnostics(''' diff --git a/test/src/lints/member_ordering/member_ordering_rule_test.dart b/test/src/lints/member_ordering/member_ordering_rule_test.dart index 6617d460..30ff152a 100644 --- a/test/src/lints/member_ordering/member_ordering_rule_test.dart +++ b/test/src/lints/member_ordering/member_ordering_rule_test.dart @@ -128,9 +128,6 @@ abstract class State { ); } - @override - String get analysisRule => MemberOrderingRule.lintName; - String _configWith(String pluginConfig) => '''${analysisOptionsContent(rules: [rule.name])} $pluginConfig'''; @@ -344,7 +341,8 @@ class WrongWidgetState extends State { '''); } - Future test_reports_on_non_alphabetical_fields_and_methods_order() async { + Future + test_reports_on_non_alphabetical_fields_and_methods_order() async { await assertAutoDiagnostics(''' class AlphabeticalClass { final b = 1; @@ -417,7 +415,8 @@ class FactoryOrder { '''); } - Future test_does_not_report_on_correct_order_with_custom_config() async { + Future + test_does_not_report_on_correct_order_with_custom_config() async { await assertNoDiagnostics(''' class CorrectOrder { final publicField = 1; @@ -462,7 +461,8 @@ class WrongOrder { '''); } - Future test_reports_on_partially_wrong_order_with_custom_config() async { + Future + test_reports_on_partially_wrong_order_with_custom_config() async { await assertAutoDiagnostics(''' class PartiallyWrongOrder { final publicField = 1; @@ -486,7 +486,8 @@ class PartiallyWrongOrder { '''); } - Future test_does_not_report_on_correct_widget_order_with_custom_config() async { + Future + test_does_not_report_on_correct_widget_order_with_custom_config() async { await assertNoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; @@ -572,7 +573,8 @@ class _WrongWidgetState extends State { '''); } - Future test_reports_on_partially_correct_widget_order_with_custom_config() async { + Future + test_reports_on_partially_correct_widget_order_with_custom_config() async { await assertAutoDiagnostics(''' import 'package:flutter/src/widgets/framework.dart'; diff --git a/test/src/lints/named_parameters_ordering/named_parameters_ordering_rule_test.dart b/test/src/lints/named_parameters_ordering/named_parameters_ordering_rule_test.dart index 7a1e82cd..9ed5e32b 100644 --- a/test/src/lints/named_parameters_ordering/named_parameters_ordering_rule_test.dart +++ b/test/src/lints/named_parameters_ordering/named_parameters_ordering_rule_test.dart @@ -46,9 +46,6 @@ plugins: ); } - @override - String get analysisRule => NamedParametersOrderingRule.lintName; - Future test_does_not_report_correct_constructor_ordering() async { await assertNoDiagnostics(r''' class Base { @@ -259,8 +256,7 @@ void example({ '''); } - Future - test_reports_incorrect_ordering_with_trailing_comments() async { + Future test_reports_incorrect_ordering_with_trailing_comments() async { await assertAutoDiagnostics(''' void example({ int? age, // the age @@ -272,8 +268,7 @@ void example({ '''); } - Future - test_reports_incorrect_ordering_with_mixed_comments() async { + Future test_reports_incorrect_ordering_with_mixed_comments() async { await assertAutoDiagnostics(''' void example({ /// The age of the user. @@ -300,8 +295,7 @@ void example({ '''); } - Future - test_does_not_report_with_partial_custom_config() async { + Future test_does_not_report_with_partial_custom_config() async { newAnalysisOptionsYamlFile(testPackageRootPath, ''' ${analysisOptionsContent(rules: [rule.name])} plugins: diff --git a/test/src/lints/no_empty_block/no_empty_block_rule_test.dart b/test/src/lints/no_empty_block/no_empty_block_rule_test.dart index f71a29e1..0199ea81 100644 --- a/test/src/lints/no_empty_block/no_empty_block_rule_test.dart +++ b/test/src/lints/no_empty_block/no_empty_block_rule_test.dart @@ -24,9 +24,6 @@ class NoEmptyBlockRuleTest extends AnalysisRuleTest with AutoTestLintOffsets { super.setUp(); } - @override - String get analysisRule => NoEmptyBlockRule.lintName; - Future test_reports_on_empty_function() async { await assertAutoDiagnostics(''' void fun() ${expectLint('{}')} @@ -60,7 +57,8 @@ void fun() { '''); } - Future test_does_not_report_on_todo_comment_with_other_comments() async { + Future + test_does_not_report_on_todo_comment_with_other_comments() async { await assertNoDiagnostics(r''' // ignore_for_file: todo void fun() { diff --git a/test/src/lints/no_magic_number/no_magic_number_rule_test.dart b/test/src/lints/no_magic_number/no_magic_number_rule_test.dart index 59df9c7f..46d7b1a8 100644 --- a/test/src/lints/no_magic_number/no_magic_number_rule_test.dart +++ b/test/src/lints/no_magic_number/no_magic_number_rule_test.dart @@ -47,8 +47,7 @@ int fn(int b) { '''); } - Future - test_reports_magic_numbers_in_ternary_comparison() async { + Future test_reports_magic_numbers_in_ternary_comparison() async { await assertAutoDiagnostics(''' bool canDrive(int age, {bool isUSA = false}) { return isUSA ? age >= ${expectLint('16')} : age > ${expectLint('18')}; @@ -308,8 +307,7 @@ void fn() { '''); } - Future - test_does_not_report_anonymous_function_default_param() async { + Future test_does_not_report_anonymous_function_default_param() async { await assertNoDiagnostics(r''' void fn() { ({int value = 7}) {}; @@ -347,8 +345,7 @@ void fn() { '''); } - Future - test_does_not_report_var_with_const_constructor_call() async { + Future test_does_not_report_var_with_const_constructor_call() async { await assertNoDiagnostics(r''' class TestOperation { final double res; @@ -361,8 +358,7 @@ void fn() { '''); } - Future - test_reports_magic_number_in_constructor_inside_list() async { + Future test_reports_magic_number_in_constructor_inside_list() async { await assertAutoDiagnostics(''' class TestOperation { final double res; @@ -376,8 +372,7 @@ void fn() { '''); } - Future - test_does_not_report_const_constructor_inside_list() async { + Future test_does_not_report_const_constructor_inside_list() async { await assertNoDiagnostics(r''' class TestOperation { final double res; diff --git a/test/src/lints/number_of_parameters/number_of_parameters_rule_test.dart b/test/src/lints/number_of_parameters/number_of_parameters_rule_test.dart index 04dd4197..2b7dd7d9 100644 --- a/test/src/lints/number_of_parameters/number_of_parameters_rule_test.dart +++ b/test/src/lints/number_of_parameters/number_of_parameters_rule_test.dart @@ -43,9 +43,6 @@ $_mockAnalysisOptionsContent''', ); } - @override - String get analysisRule => NumberOfParametersRule.lintName; - Future test_reports_on_exceeding_max_parameters() async { await assertAutoDiagnostics(''' void fun${expectLint(r'(int a, int b, int c)')} {} diff --git a/test/src/utils/auto_lint_data.dart b/test/src/utils/auto_lint_data.dart new file mode 100644 index 00000000..f0aa562b --- /dev/null +++ b/test/src/utils/auto_lint_data.dart @@ -0,0 +1,17 @@ +import 'package:analyzer_testing/src/analysis_rule/pub_package_resolution.dart'; + +class AutoLintData { + final String code; + final Pattern? correctionContains; + final List messageContainsAll; + final String? name; + final List? contextMessages; + + const AutoLintData({ + required this.code, + this.correctionContains, + this.messageContainsAll = const [], + this.name, + this.contextMessages, + }); +} diff --git a/test/utils/fake_analysis_options_loader.dart b/test/utils/fake_analysis_options_loader.dart index c8683879..777abb87 100644 --- a/test/utils/fake_analysis_options_loader.dart +++ b/test/utils/fake_analysis_options_loader.dart @@ -10,6 +10,13 @@ class FakeAnalysisOptionsLoader implements AnalysisOptionsLoader { Map? getRuleOptions(RuleContext context, String ruleName) => ruleOptions; + @override + Map? getRuleOptionsForFile( + String filePath, + String ruleName, + ) => + ruleOptions; + @override void loadRulesOptionsFromContext(RuleContext context) {} }