Repository: mgechev/revive
Pull request #1108 (2024-11-11 12:10:38)

refactor: rename files to follow Go convention
The PR renames all Go files to match a filename with standard Go convention: filenames should be lowercased with `_`. Additionally, enables the `filename-format` rule with the argument `"^[_a-z][_a-z0-9]*.go$"` to enforce this convention.

Follows #1088 and https://github.com/mgechev/revive/pull/1088#issuecomment-2445190208

ccoVeille: I hope it will get merged soon.

Great changes

Patch:
diff --git a/lint/linter.go b/lint/linter.go
index 56036e8..2bd8355 100644
--- a/lint/linter.go
+++ b/lint/linter.go
@@ -173,6 +173,10 @@ func detectGoMod(dir string) (rootDir string, ver *goversion.Version, err error)
 		return "", nil, fmt.Errorf("failed to parse %q, got %v", modFileName, err)
 	}
 
+	if modAst.Go == nil {
+		return "", nil, fmt.Errorf("%q does not specify a Go version", modFileName)
+	}
+
 	ver, err = goversion.NewVersion(modAst.Go.Version)
 	return filepath.Dir(modFileName), ver, err
 }
diff --git a/revive.toml b/revive.toml
index 3d47522..304909d 100644
--- a/revive.toml
+++ b/revive.toml
@@ -19,6 +19,9 @@ warningCode = 1
 [rule.error-strings]
 [rule.errorf]
 [rule.exported]
+[rule.filename-format]
+    # Override the default pattern to forbid .go files with uppercase letters and dashes.
+    arguments=["^[_a-z][_a-z0-9]*.go$"]
 [rule.increment-decrement]
 [rule.indent-error-flow]
 [rule.line-length-limit]


Test patch:
diff --git a/revivelib/core_test.go b/revivelib/core_test.go
index 045711a..10670c7 100644
--- a/revivelib/core_test.go
+++ b/revivelib/core_test.go
@@ -16,7 +16,7 @@ func TestReviveLint(t *testing.T) {
 	revive := getMockRevive(t)
 
 	// ACT
-	failures, err := revive.Lint(revivelib.Include("../testdata/if-return.go"))
+	failures, err := revive.Lint(revivelib.Include("../testdata/if_return.go"))
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -40,7 +40,7 @@ func TestReviveFormat(t *testing.T) {
 	// ARRANGE
 	revive := getMockRevive(t)
 
-	failuresChan, err := revive.Lint(revivelib.Include("../testdata/if-return.go"))
+	failuresChan, err := revive.Lint(revivelib.Include("../testdata/if_return.go"))
 	if err != nil {
 		t.Fatal(err)
 	}
diff --git a/rule/add-constant.go b/rule/add_constant.go
similarity index 100%
rename from rule/add-constant.go
rename to rule/add_constant.go
diff --git a/rule/argument-limit.go b/rule/argument_limit.go
similarity index 100%
rename from rule/argument-limit.go
rename to rule/argument_limit.go
diff --git a/rule/banned-characters.go b/rule/banned_characters.go
similarity index 100%
rename from rule/banned-characters.go
rename to rule/banned_characters.go
diff --git a/rule/bare-return.go b/rule/bare_return.go
similarity index 100%
rename from rule/bare-return.go
rename to rule/bare_return.go
diff --git a/rule/blank-imports.go b/rule/blank_imports.go
similarity index 100%
rename from rule/blank-imports.go
rename to rule/blank_imports.go
diff --git a/rule/bool-literal-in-expr.go b/rule/bool_literal_in_expr.go
similarity index 100%
rename from rule/bool-literal-in-expr.go
rename to rule/bool_literal_in_expr.go
diff --git a/rule/call-to-gc.go b/rule/call_to_gc.go
similarity index 100%
rename from rule/call-to-gc.go
rename to rule/call_to_gc.go
diff --git a/rule/cognitive-complexity.go b/rule/cognitive_complexity.go
similarity index 100%
rename from rule/cognitive-complexity.go
rename to rule/cognitive_complexity.go
diff --git a/rule/comment-spacings.go b/rule/comment_spacings.go
similarity index 100%
rename from rule/comment-spacings.go
rename to rule/comment_spacings.go
diff --git a/rule/comments-density.go b/rule/comments_density.go
similarity index 100%
rename from rule/comments-density.go
rename to rule/comments_density.go
diff --git a/rule/confusing-naming.go b/rule/confusing_naming.go
similarity index 100%
rename from rule/confusing-naming.go
rename to rule/confusing_naming.go
diff --git a/rule/confusing-results.go b/rule/confusing_results.go
similarity index 100%
rename from rule/confusing-results.go
rename to rule/confusing_results.go
diff --git a/rule/constant-logical-expr.go b/rule/constant_logical_expr.go
similarity index 100%
rename from rule/constant-logical-expr.go
rename to rule/constant_logical_expr.go
diff --git a/rule/context-as-argument.go b/rule/context_as_argument.go
similarity index 100%
rename from rule/context-as-argument.go
rename to rule/context_as_argument.go
diff --git a/rule/context-keys-type.go b/rule/context_keys_type.go
similarity index 100%
rename from rule/context-keys-type.go
rename to rule/context_keys_type.go
diff --git a/rule/deep-exit.go b/rule/deep_exit.go
similarity index 100%
rename from rule/deep-exit.go
rename to rule/deep_exit.go
diff --git a/rule/dot-imports.go b/rule/dot_imports.go
similarity index 100%
rename from rule/dot-imports.go
rename to rule/dot_imports.go
diff --git a/rule/duplicated-imports.go b/rule/duplicated_imports.go
similarity index 100%
rename from rule/duplicated-imports.go
rename to rule/duplicated_imports.go
diff --git a/rule/early-return.go b/rule/early_return.go
similarity index 100%
rename from rule/early-return.go
rename to rule/early_return.go
diff --git a/rule/empty-block.go b/rule/empty_block.go
similarity index 100%
rename from rule/empty-block.go
rename to rule/empty_block.go
diff --git a/rule/empty-lines.go b/rule/empty_lines.go
similarity index 100%
rename from rule/empty-lines.go
rename to rule/empty_lines.go
diff --git a/rule/enforce-map-style.go b/rule/enforce_map_style.go
similarity index 100%
rename from rule/enforce-map-style.go
rename to rule/enforce_map_style.go
diff --git a/rule/enforce-repeated-arg-type-style.go b/rule/enforce_repeated_arg_type_style.go
similarity index 100%
rename from rule/enforce-repeated-arg-type-style.go
rename to rule/enforce_repeated_arg_type_style.go
diff --git a/rule/enforce-slice-style.go b/rule/enforce_slice_style.go
similarity index 100%
rename from rule/enforce-slice-style.go
rename to rule/enforce_slice_style.go
diff --git a/rule/error-naming.go b/rule/error_naming.go
similarity index 100%
rename from rule/error-naming.go
rename to rule/error_naming.go
diff --git a/rule/error-return.go b/rule/error_return.go
similarity index 100%
rename from rule/error-return.go
rename to rule/error_return.go
diff --git a/rule/error-strings.go b/rule/error_strings.go
similarity index 100%
rename from rule/error-strings.go
rename to rule/error_strings.go
diff --git a/rule/file-header.go b/rule/file_header.go
similarity index 100%
rename from rule/file-header.go
rename to rule/file_header.go
diff --git a/rule/file-length-limit.go b/rule/file_length_limit.go
similarity index 100%
rename from rule/file-length-limit.go
rename to rule/file_length_limit.go
diff --git a/rule/filename-format.go b/rule/filename_format.go
similarity index 100%
rename from rule/filename-format.go
rename to rule/filename_format.go
diff --git a/rule/flag-param.go b/rule/flag_param.go
similarity index 100%
rename from rule/flag-param.go
rename to rule/flag_param.go
diff --git a/rule/function-length.go b/rule/function_length.go
similarity index 100%
rename from rule/function-length.go
rename to rule/function_length.go
diff --git a/rule/function-result-limit.go b/rule/function_result_limit.go
similarity index 100%
rename from rule/function-result-limit.go
rename to rule/function_result_limit.go
diff --git a/rule/get-return.go b/rule/get_return.go
similarity index 100%
rename from rule/get-return.go
rename to rule/get_return.go
diff --git a/rule/identical-branches.go b/rule/identical_branches.go
similarity index 100%
rename from rule/identical-branches.go
rename to rule/identical_branches.go
diff --git a/rule/if-return.go b/rule/if_return.go
similarity index 100%
rename from rule/if-return.go
rename to rule/if_return.go
diff --git a/rule/import-alias-naming.go b/rule/import_alias_naming.go
similarity index 100%
rename from rule/import-alias-naming.go
rename to rule/import_alias_naming.go
diff --git a/rule/import-shadowing.go b/rule/import_shadowing.go
similarity index 100%
rename from rule/import-shadowing.go
rename to rule/import_shadowing.go
diff --git a/rule/imports-blocklist.go b/rule/imports_blocklist.go
similarity index 100%
rename from rule/imports-blocklist.go
rename to rule/imports_blocklist.go
diff --git a/rule/increment-decrement.go b/rule/increment_decrement.go
similarity index 100%
rename from rule/increment-decrement.go
rename to rule/increment_decrement.go
diff --git a/rule/indent-error-flow.go b/rule/indent_error_flow.go
similarity index 100%
rename from rule/indent-error-flow.go
rename to rule/indent_error_flow.go
diff --git a/rule/line-length-limit.go b/rule/line_length_limit.go
similarity index 100%
rename from rule/line-length-limit.go
rename to rule/line_length_limit.go
diff --git a/rule/max-control-nesting.go b/rule/max_control_nesting.go
similarity index 100%
rename from rule/max-control-nesting.go
rename to rule/max_control_nesting.go
diff --git a/rule/max-public-structs.go b/rule/max_public_structs.go
similarity index 100%
rename from rule/max-public-structs.go
rename to rule/max_public_structs.go
diff --git a/rule/modifies-param.go b/rule/modifies_param.go
similarity index 100%
rename from rule/modifies-param.go
rename to rule/modifies_param.go
diff --git a/rule/modifies-value-receiver.go b/rule/modifies_value_receiver.go
similarity index 100%
rename from rule/modifies-value-receiver.go
rename to rule/modifies_value_receiver.go
diff --git a/rule/nested-structs.go b/rule/nested_structs.go
similarity index 100%
rename from rule/nested-structs.go
rename to rule/nested_structs.go
diff --git a/rule/optimize-operands-order.go b/rule/optimize_operands_order.go
similarity index 100%
rename from rule/optimize-operands-order.go
rename to rule/optimize_operands_order.go
diff --git a/rule/package-comments.go b/rule/package_comments.go
similarity index 100%
rename from rule/package-comments.go
rename to rule/package_comments.go
diff --git a/rule/range-val-address.go b/rule/range_val_address.go
similarity index 100%
rename from rule/range-val-address.go
rename to rule/range_val_address.go
diff --git a/rule/range-val-in-closure.go b/rule/range_val_in_closure.go
similarity index 100%
rename from rule/range-val-in-closure.go
rename to rule/range_val_in_closure.go
diff --git a/rule/receiver-naming.go b/rule/receiver_naming.go
similarity index 100%
rename from rule/receiver-naming.go
rename to rule/receiver_naming.go
diff --git a/rule/redefines-builtin-id.go b/rule/redefines_builtin_id.go
similarity index 100%
rename from rule/redefines-builtin-id.go
rename to rule/redefines_builtin_id.go
diff --git a/rule/redundant-import-alias.go b/rule/redundant_import_alias.go
similarity index 100%
rename from rule/redundant-import-alias.go
rename to rule/redundant_import_alias.go
diff --git a/rule/string-format.go b/rule/string_format.go
similarity index 100%
rename from rule/string-format.go
rename to rule/string_format.go
diff --git a/rule/string-of-int.go b/rule/string_of_int.go
similarity index 100%
rename from rule/string-of-int.go
rename to rule/string_of_int.go
diff --git a/rule/struct-tag.go b/rule/struct_tag.go
similarity index 100%
rename from rule/struct-tag.go
rename to rule/struct_tag.go
diff --git a/rule/superfluous-else.go b/rule/superfluous_else.go
similarity index 100%
rename from rule/superfluous-else.go
rename to rule/superfluous_else.go
diff --git a/rule/time-equal.go b/rule/time_equal.go
similarity index 100%
rename from rule/time-equal.go
rename to rule/time_equal.go
diff --git a/rule/time-naming.go b/rule/time_naming.go
similarity index 100%
rename from rule/time-naming.go
rename to rule/time_naming.go
diff --git a/rule/unchecked-type-assertion.go b/rule/unchecked_type_assertion.go
similarity index 100%
rename from rule/unchecked-type-assertion.go
rename to rule/unchecked_type_assertion.go
diff --git a/rule/unconditional-recursion.go b/rule/unconditional_recursion.go
similarity index 100%
rename from rule/unconditional-recursion.go
rename to rule/unconditional_recursion.go
diff --git a/rule/unexported-naming.go b/rule/unexported_naming.go
similarity index 100%
rename from rule/unexported-naming.go
rename to rule/unexported_naming.go
diff --git a/rule/unexported-return.go b/rule/unexported_return.go
similarity index 100%
rename from rule/unexported-return.go
rename to rule/unexported_return.go
diff --git a/rule/unhandled-error.go b/rule/unhandled_error.go
similarity index 100%
rename from rule/unhandled-error.go
rename to rule/unhandled_error.go
diff --git a/rule/unnecessary-stmt.go b/rule/unnecessary_stmt.go
similarity index 100%
rename from rule/unnecessary-stmt.go
rename to rule/unnecessary_stmt.go
diff --git a/rule/unreachable-code.go b/rule/unreachable_code.go
similarity index 100%
rename from rule/unreachable-code.go
rename to rule/unreachable_code.go
diff --git a/rule/unused-param.go b/rule/unused_param.go
similarity index 100%
rename from rule/unused-param.go
rename to rule/unused_param.go
diff --git a/rule/unused-receiver.go b/rule/unused_receiver.go
similarity index 100%
rename from rule/unused-receiver.go
rename to rule/unused_receiver.go
diff --git a/rule/use-any.go b/rule/use_any.go
similarity index 100%
rename from rule/use-any.go
rename to rule/use_any.go
diff --git a/rule/useless-break.go b/rule/useless_break.go
similarity index 100%
rename from rule/useless-break.go
rename to rule/useless_break.go
diff --git a/rule/var-declarations.go b/rule/var_declarations.go
similarity index 100%
rename from rule/var-declarations.go
rename to rule/var_declarations.go
diff --git a/rule/var-naming.go b/rule/var_naming.go
similarity index 100%
rename from rule/var-naming.go
rename to rule/var_naming.go
diff --git a/rule/waitgroup-by-value.go b/rule/waitgroup_by_value.go
similarity index 100%
rename from rule/waitgroup-by-value.go
rename to rule/waitgroup_by_value.go
diff --git a/test/add-constant_test.go b/test/add_constant_test.go
similarity index 86%
rename from test/add-constant_test.go
rename to test/add_constant_test.go
index 45ce291..6480ed5 100644
--- a/test/add-constant_test.go
+++ b/test/add_constant_test.go
@@ -16,7 +16,7 @@ func TestAddConstant(t *testing.T) {
 		"ignoreFuncs": "os\\.(CreateFile|WriteFile|Chmod|FindProcess),\\.Println,ignoredFunc,\\.Info",
 	}}
 
-	testRule(t, "add-constant", &rule.AddConstantRule{}, &lint.RuleConfig{
+	testRule(t, "add_constant", &rule.AddConstantRule{}, &lint.RuleConfig{
 		Arguments: args,
 	})
 }
diff --git a/test/argument-limit_test.go b/test/argument_limit_test.go
similarity index 75%
rename from test/argument-limit_test.go
rename to test/argument_limit_test.go
index 1fd598c..c4f0d93 100644
--- a/test/argument-limit_test.go
+++ b/test/argument_limit_test.go
@@ -8,7 +8,7 @@ import (
 )
 
 func TestArgumentLimit(t *testing.T) {
-	testRule(t, "argument-limit", &rule.ArgumentsLimitRule{}, &lint.RuleConfig{
+	testRule(t, "argument_limit", &rule.ArgumentsLimitRule{}, &lint.RuleConfig{
 		Arguments: []any{int64(3)},
 	})
 }
diff --git a/test/banned-characters_test.go b/test/banned_characters_test.go
similarity index 86%
rename from test/banned-characters_test.go
rename to test/banned_characters_test.go
index 362ce8b..a639842 100644
--- a/test/banned-characters_test.go
+++ b/test/banned_characters_test.go
@@ -11,7 +11,7 @@ import (
 // One banned character is in the comment and should not be checked.
 // One banned character from the list is not present in the fixture file.
 func TestBannedCharacters(t *testing.T) {
-	testRule(t, "banned-characters", &rule.BannedCharsRule{}, &lint.RuleConfig{
+	testRule(t, "banned_characters", &rule.BannedCharsRule{}, &lint.RuleConfig{
 		Arguments: []any{"Ω", "Σ", "σ", "1"},
 	})
 }
diff --git a/test/bare-return_test.go b/test/bare_return_test.go
similarity index 67%
rename from test/bare-return_test.go
rename to test/bare_return_test.go
index 1741334..4049efc 100644
--- a/test/bare-return_test.go
+++ b/test/bare_return_test.go
@@ -7,5 +7,5 @@ import (
 )
 
 func TestBareReturn(t *testing.T) {
-	testRule(t, "bare-return", &rule.BareReturnRule{})
+	testRule(t, "bare_return", &rule.BareReturnRule{})
 }
diff --git a/test/bool-literal-in-expr_test.go b/test/bool_literal_in_expr_test.go
similarity index 68%
rename from test/bool-literal-in-expr_test.go
rename to test/bool_literal_in_expr_test.go
index 445ee93..d67c6d2 100644
--- a/test/bool-literal-in-expr_test.go
+++ b/test/bool_literal_in_expr_test.go
@@ -8,5 +8,5 @@ import (
 
 // BoolLiteral rule.
 func TestBoolLiteral(t *testing.T) {
-	testRule(t, "bool-literal-in-expr", &rule.BoolLiteralRule{})
+	testRule(t, "bool_literal_in_expr", &rule.BoolLiteralRule{})
 }
diff --git a/test/call-to-gc_test.go b/test/call_to_gc_test.go
similarity index 74%
rename from test/call-to-gc_test.go
rename to test/call_to_gc_test.go
index a678d83..9c11ad4 100644
--- a/test/call-to-gc_test.go
+++ b/test/call_to_gc_test.go
@@ -8,5 +8,5 @@ import (
 
 // TestCallToGC test call-to-gc rule
 func TestCallToGC(t *testing.T) {
-	testRule(t, "call-to-gc", &rule.CallToGCRule{})
+	testRule(t, "call_to_gc", &rule.CallToGCRule{})
 }
diff --git a/test/cognitive-complexity_test.go b/test/cognitive_complexity_test.go
similarity index 76%
rename from test/cognitive-complexity_test.go
rename to test/cognitive_complexity_test.go
index ae2c59a..f35a445 100644
--- a/test/cognitive-complexity_test.go
+++ b/test/cognitive_complexity_test.go
@@ -8,7 +8,7 @@ import (
 )
 
 func TestCognitiveComplexity(t *testing.T) {
-	testRule(t, "cognitive-complexity", &rule.CognitiveComplexityRule{}, &lint.RuleConfig{
+	testRule(t, "cognitive_complexity", &rule.CognitiveComplexityRule{}, &lint.RuleConfig{
 		Arguments: []any{int64(0)},
 	})
 }
diff --git a/test/comment-spacings_test.go b/test/comment_spacings_test.go
similarity index 77%
rename from test/comment-spacings_test.go
rename to test/comment_spacings_test.go
index e7abeb7..4a1300c 100644
--- a/test/comment-spacings_test.go
+++ b/test/comment_spacings_test.go
@@ -8,7 +8,7 @@ import (
 )
 
 func TestCommentSpacings(t *testing.T) {
-	testRule(t, "comment-spacings", &rule.CommentSpacingsRule{}, &lint.RuleConfig{
+	testRule(t, "comment_spacings", &rule.CommentSpacingsRule{}, &lint.RuleConfig{
 		Arguments: []any{"myOwnDirective:", "+optional"}},
 	)
 }
diff --git a/test/comments-density_test.go b/test/comments_density_test.go
similarity index 59%
rename from test/comments-density_test.go
rename to test/comments_density_test.go
index 3d15f1f..df72ff8 100644
--- a/test/comments-density_test.go
+++ b/test/comments_density_test.go
@@ -8,13 +8,13 @@ import (
 )
 
 func TestCommentsDensity(t *testing.T) {
-	testRule(t, "comments-density-1", &rule.CommentsDensityRule{}, &lint.RuleConfig{
+	testRule(t, "comments_density_1", &rule.CommentsDensityRule{}, &lint.RuleConfig{
 		Arguments: []any{int64(60)},
 	})
 
-	testRule(t, "comments-density-2", &rule.CommentsDensityRule{}, &lint.RuleConfig{
+	testRule(t, "comments_density_2", &rule.CommentsDensityRule{}, &lint.RuleConfig{
 		Arguments: []any{int64(90)},
 	})
 
-	testRule(t, "comments-density-3", &rule.CommentsDensityRule{}, &lint.RuleConfig{})
+	testRule(t, "comments_density_3", &rule.CommentsDensityRule{}, &lint.RuleConfig{})
 }
diff --git a/test/confusing-naming_test.go b/test/confusing_naming_test.go
similarity index 69%
rename from test/confusing-naming_test.go
rename to test/confusing_naming_test.go
index 42f57fe..22f44fe 100644
--- a/test/confusing-naming_test.go
+++ b/test/confusing_naming_test.go
@@ -8,5 +8,5 @@ import (
 
 // TestConfusingNaming rule.
 func TestConfusingNaming(t *testing.T) {
-	testRule(t, "confusing-naming1", &rule.ConfusingNamingRule{})
+	testRule(t, "confusing_naming1", &rule.ConfusingNamingRule{})
 }
diff --git a/test/confusing-results_test.go b/test/confusing_results_test.go
similarity index 64%
rename from test/confusing-results_test.go
rename to test/confusing_results_test.go
index 5a8f2c5..38d64e6 100644
--- a/test/confusing-results_test.go
+++ b/test/confusing_results_test.go
@@ -7,5 +7,5 @@ import (
 )
 
 func TestConfusingResults(t *testing.T) {
-	testRule(t, "confusing-results", &rule.ConfusingResultsRule{})
+	testRule(t, "confusing_results", &rule.ConfusingResultsRule{})
 }
diff --git a/test/constant-logical-expr_test.go b/test/constant_logical_expr_test.go
similarity index 70%
rename from test/constant-logical-expr_test.go
rename to test/constant_logical_expr_test.go
index bb80ade..d3d6d90 100644
--- a/test/constant-logical-expr_test.go
+++ b/test/constant_logical_expr_test.go
@@ -8,5 +8,5 @@ import (
 
 // ConstantLogicalExpr rule.
 func TestConstantLogicalExpr(t *testing.T) {
-	testRule(t, "constant-logical-expr", &rule.ConstantLogicalExprRule{})
+	testRule(t, "constant_logical_expr", &rule.ConstantLogicalExprRule{})
 }
diff --git a/test/context-as-argument_test.go b/test/context_as_argument_test.go
similarity index 83%
rename from test/context-as-argument_test.go
rename to test/context_as_argument_test.go
index f0b00ab..2e8af0a 100644
--- a/test/context-as-argument_test.go
+++ b/test/context_as_argument_test.go
@@ -8,7 +8,7 @@ import (
 )
 
 func TestContextAsArgument(t *testing.T) {
-	testRule(t, "context-as-argument", &rule.ContextAsArgumentRule{}, &lint.RuleConfig{
+	testRule(t, "context_as_argument", &rule.ContextAsArgumentRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"allowTypesBefore": "AllowedBeforeType,AllowedBeforeStruct,*AllowedBeforePtrStruct,*testing.T",
diff --git a/test/cyclomatic_test.go b/test/cyclomatic_test.go
index bdae80d..cdfce30 100644
--- a/test/cyclomatic_test.go
+++ b/test/cyclomatic_test.go
@@ -11,7 +11,7 @@ func TestCyclomatic(t *testing.T) {
 	testRule(t, "cyclomatic", &rule.CyclomaticRule{}, &lint.RuleConfig{
 		Arguments: []any{int64(1)},
 	})
-	testRule(t, "cyclomatic-2", &rule.CyclomaticRule{}, &lint.RuleConfig{
+	testRule(t, "cyclomatic_2", &rule.CyclomaticRule{}, &lint.RuleConfig{
 		Arguments: []any{int64(3)},
 	})
 }
diff --git a/test/deep-exit_test.go b/test/deep_exit_test.go
similarity index 51%
rename from test/deep-exit_test.go
rename to test/deep_exit_test.go
index 47e70e3..af57efe 100644
--- a/test/deep-exit_test.go
+++ b/test/deep_exit_test.go
@@ -7,6 +7,6 @@ import (
 )
 
 func TestDeepExit(t *testing.T) {
-	testRule(t, "deep-exit", &rule.DeepExitRule{})
-	testRule(t, "deep-exit_test", &rule.DeepExitRule{})
+	testRule(t, "deep_exit", &rule.DeepExitRule{})
+	testRule(t, "deep_exit_test", &rule.DeepExitRule{})
 }
diff --git a/test/defer_test.go b/test/defer_test.go
index 2066eaa..ce2904a 100644
--- a/test/defer_test.go
+++ b/test/defer_test.go
@@ -13,13 +13,13 @@ func TestDefer(t *testing.T) {
 }
 
 func TestDeferLoopDisabled(t *testing.T) {
-	testRule(t, "defer-loop-disabled", &rule.DeferRule{}, &lint.RuleConfig{
+	testRule(t, "defer_loop_disabled", &rule.DeferRule{}, &lint.RuleConfig{
 		Arguments: []any{[]any{"return", "recover", "call-chain", "method-call"}},
 	})
 }
 
 func TestDeferOthersDisabled(t *testing.T) {
-	testRule(t, "defer-only-loop-enabled", &rule.DeferRule{}, &lint.RuleConfig{
+	testRule(t, "defer_only_loop_enabled", &rule.DeferRule{}, &lint.RuleConfig{
 		Arguments: []any{[]any{"loop"}},
 	})
 }
diff --git a/test/disable-annotations_test.go b/test/disable_annotations_test.go
similarity index 61%
rename from test/disable-annotations_test.go
rename to test/disable_annotations_test.go
index bb05b00..be913b4 100644
--- a/test/disable-annotations_test.go
+++ b/test/disable_annotations_test.go
@@ -8,13 +8,13 @@ import (
 )
 
 func TestDisabledAnnotations(t *testing.T) {
-	testRule(t, "disable-annotations", &rule.ExportedRule{}, &lint.RuleConfig{})
+	testRule(t, "disable_annotations", &rule.ExportedRule{}, &lint.RuleConfig{})
 }
 
 func TestModifiedAnnotations(t *testing.T) {
-	testRule(t, "disable-annotations2", &rule.VarNamingRule{}, &lint.RuleConfig{})
+	testRule(t, "disable_annotations2", &rule.VarNamingRule{}, &lint.RuleConfig{})
 }
 
 func TestDisableNextLineAnnotations(t *testing.T) {
-	testRule(t, "disable-annotations3", &rule.VarNamingRule{}, &lint.RuleConfig{})
+	testRule(t, "disable_annotations3", &rule.VarNamingRule{}, &lint.RuleConfig{})
 }
diff --git a/test/dot_imports_test.go b/test/dot_imports_test.go
index 31cd4bd..e6067a6 100644
--- a/test/dot_imports_test.go
+++ b/test/dot_imports_test.go
@@ -12,7 +12,7 @@ func TestDotImports(t *testing.T) {
 		"allowedPackages": []any{"errors", "context", "github.com/BurntSushi/toml"},
 	}}
 
-	testRule(t, "import-dot", &rule.DotImportsRule{}, &lint.RuleConfig{
+	testRule(t, "import_dot", &rule.DotImportsRule{}, &lint.RuleConfig{
 		Arguments: args,
 	})
 }
diff --git a/test/duplicated-import_test.go b/test/duplicated_imports_test.go
similarity index 65%
rename from test/duplicated-import_test.go
rename to test/duplicated_imports_test.go
index 4cdb897..d4b4be9 100644
--- a/test/duplicated-import_test.go
+++ b/test/duplicated_imports_test.go
@@ -7,5 +7,5 @@ import (
 )
 
 func TestDuplicatedImports(t *testing.T) {
-	testRule(t, "duplicated-imports", &rule.DuplicatedImportsRule{})
+	testRule(t, "duplicated_imports", &rule.DuplicatedImportsRule{})
 }
diff --git a/test/early-return_test.go b/test/early_return_test.go
similarity index 70%
rename from test/early-return_test.go
rename to test/early_return_test.go
index 2970649..b477c6d 100644
--- a/test/early-return_test.go
+++ b/test/early_return_test.go
@@ -10,6 +10,6 @@ import (
 
 // TestEarlyReturn tests early-return rule.
 func TestEarlyReturn(t *testing.T) {
-	testRule(t, "early-return", &rule.EarlyReturnRule{})
-	testRule(t, "early-return-scope", &rule.EarlyReturnRule{}, &lint.RuleConfig{Arguments: []any{ifelse.PreserveScope}})
+	testRule(t, "early_return", &rule.EarlyReturnRule{})
+	testRule(t, "early_return_scope", &rule.EarlyReturnRule{}, &lint.RuleConfig{Arguments: []any{ifelse.PreserveScope}})
 }
diff --git a/test/empty-block_test.go b/test/empty_block_test.go
similarity index 72%
rename from test/empty-block_test.go
rename to test/empty_block_test.go
index 1de0680..bc496d4 100644
--- a/test/empty-block_test.go
+++ b/test/empty_block_test.go
@@ -8,5 +8,5 @@ import (
 
 // TestEmptyBlock rule.
 func TestEmptyBlock(t *testing.T) {
-	testRule(t, "empty-block", &rule.EmptyBlockRule{})
+	testRule(t, "empty_block", &rule.EmptyBlockRule{})
 }
diff --git a/test/empty-lines_test.go b/test/empty_lines_test.go
similarity index 72%
rename from test/empty-lines_test.go
rename to test/empty_lines_test.go
index ef27605..e74d9f1 100644
--- a/test/empty-lines_test.go
+++ b/test/empty_lines_test.go
@@ -8,5 +8,5 @@ import (
 
 // TestEmptyLines rule.
 func TestEmptyLines(t *testing.T) {
-	testRule(t, "empty-lines", &rule.EmptyLinesRule{})
+	testRule(t, "empty_lines", &rule.EmptyLinesRule{})
 }
diff --git a/test/enforce-map-style_test.go b/test/enforce_map_style_test.go
similarity index 65%
rename from test/enforce-map-style_test.go
rename to test/enforce_map_style_test.go
index 83d68c6..dd36ff2 100644
--- a/test/enforce-map-style_test.go
+++ b/test/enforce_map_style_test.go
@@ -8,17 +8,17 @@ import (
 )
 
 func TestEnforceMapStyle_any(t *testing.T) {
-	testRule(t, "enforce-map-style-any", &rule.EnforceMapStyleRule{})
+	testRule(t, "enforce_map_style_any", &rule.EnforceMapStyleRule{})
 }
 
 func TestEnforceMapStyle_make(t *testing.T) {
-	testRule(t, "enforce-map-style-make", &rule.EnforceMapStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_map_style_make", &rule.EnforceMapStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{"make"},
 	})
 }
 
 func TestEnforceMapStyle_literal(t *testing.T) {
-	testRule(t, "enforce-map-style-literal", &rule.EnforceMapStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_map_style_literal", &rule.EnforceMapStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{"literal"},
 	})
 }
diff --git a/test/enforce-repeated-arg-type-style_test.go b/test/enforce_repeated_arg_type_style_test.go
similarity index 70%
rename from test/enforce-repeated-arg-type-style_test.go
rename to test/enforce_repeated_arg_type_style_test.go
index c2913dd..51c18bb 100644
--- a/test/enforce-repeated-arg-type-style_test.go
+++ b/test/enforce_repeated_arg_type_style_test.go
@@ -8,21 +8,21 @@ import (
 )
 
 func TestEnforceRepeatedArgTypeStyleShort(t *testing.T) {
-	testRule(t, "enforce-repeated-arg-type-style-short-args", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_short_args", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{"short"},
 	})
-	testRule(t, "enforce-repeated-arg-type-style-short-return", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_short_return", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{"short"},
 	})
 
-	testRule(t, "enforce-repeated-arg-type-style-short-args", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_short_args", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"funcArgStyle": `short`,
 			},
 		},
 	})
-	testRule(t, "enforce-repeated-arg-type-style-short-return", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_short_return", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"funcRetValStyle": `short`,
@@ -32,21 +32,21 @@ func TestEnforceRepeatedArgTypeStyleShort(t *testing.T) {
 }
 
 func TestEnforceRepeatedArgTypeStyleFull(t *testing.T) {
-	testRule(t, "enforce-repeated-arg-type-style-full-args", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_full_args", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{"full"},
 	})
-	testRule(t, "enforce-repeated-arg-type-style-full-return", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_full_return", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{"full"},
 	})
 
-	testRule(t, "enforce-repeated-arg-type-style-full-args", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_full_args", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"funcArgStyle": `full`,
 			},
 		},
 	})
-	testRule(t, "enforce-repeated-arg-type-style-full-return", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_full_return", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"funcRetValStyle": `full`,
@@ -56,14 +56,14 @@ func TestEnforceRepeatedArgTypeStyleFull(t *testing.T) {
 }
 
 func TestEnforceRepeatedArgTypeStyleMixed(t *testing.T) {
-	testRule(t, "enforce-repeated-arg-type-style-full-args", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_full_args", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"funcArgStyle": `full`,
 			},
 		},
 	})
-	testRule(t, "enforce-repeated-arg-type-style-full-args", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_full_args", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"funcArgStyle":    `full`,
@@ -71,7 +71,7 @@ func TestEnforceRepeatedArgTypeStyleMixed(t *testing.T) {
 			},
 		},
 	})
-	testRule(t, "enforce-repeated-arg-type-style-full-args", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_full_args", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"funcArgStyle":    `full`,
@@ -80,14 +80,14 @@ func TestEnforceRepeatedArgTypeStyleMixed(t *testing.T) {
 		},
 	})
 
-	testRule(t, "enforce-repeated-arg-type-style-full-return", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_full_return", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"funcRetValStyle": `full`,
 			},
 		},
 	})
-	testRule(t, "enforce-repeated-arg-type-style-full-return", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_full_return", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"funcArgStyle":    `any`,
@@ -95,7 +95,7 @@ func TestEnforceRepeatedArgTypeStyleMixed(t *testing.T) {
 			},
 		},
 	})
-	testRule(t, "enforce-repeated-arg-type-style-full-return", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_full_return", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"funcArgStyle":    `short`,
@@ -104,7 +104,7 @@ func TestEnforceRepeatedArgTypeStyleMixed(t *testing.T) {
 		},
 	})
 
-	testRule(t, "enforce-repeated-arg-type-style-mixed-full-short", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_mixed_full_short", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"funcArgStyle":    `full`,
@@ -112,7 +112,7 @@ func TestEnforceRepeatedArgTypeStyleMixed(t *testing.T) {
 			},
 		},
 	})
-	testRule(t, "enforce-repeated-arg-type-style-mixed-short-full", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_repeated_arg_type_style_mixed_short_full", &rule.EnforceRepeatedArgTypeStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"funcArgStyle":    `short`,
diff --git a/test/enforce-slice-style_test.go b/test/enforce_slice_style_test.go
similarity index 65%
rename from test/enforce-slice-style_test.go
rename to test/enforce_slice_style_test.go
index 55d0c11..b0ee568 100644
--- a/test/enforce-slice-style_test.go
+++ b/test/enforce_slice_style_test.go
@@ -8,23 +8,23 @@ import (
 )
 
 func TestEnforceSliceStyle_any(t *testing.T) {
-	testRule(t, "enforce-slice-style-any", &rule.EnforceSliceStyleRule{})
+	testRule(t, "enforce_slice_style_any", &rule.EnforceSliceStyleRule{})
 }
 
 func TestEnforceSliceStyle_make(t *testing.T) {
-	testRule(t, "enforce-slice-style-make", &rule.EnforceSliceStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_slice_style_make", &rule.EnforceSliceStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{"make"},
 	})
 }
 
 func TestEnforceSliceStyle_literal(t *testing.T) {
-	testRule(t, "enforce-slice-style-literal", &rule.EnforceSliceStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_slice_style_literal", &rule.EnforceSliceStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{"literal"},
 	})
 }
 
 func TestEnforceSliceStyle_nil(t *testing.T) {
-	testRule(t, "enforce-slice-style-nil", &rule.EnforceSliceStyleRule{}, &lint.RuleConfig{
+	testRule(t, "enforce_slice_style_nil", &rule.EnforceSliceStyleRule{}, &lint.RuleConfig{
 		Arguments: []any{"nil"},
 	})
 }
diff --git a/test/error-strings-custom-functions_test.go b/test/error_strings_custom_functions_test.go
similarity index 79%
rename from test/error-strings-custom-functions_test.go
rename to test/error_strings_custom_functions_test.go
index 005ddfe..5cd67e4 100644
--- a/test/error-strings-custom-functions_test.go
+++ b/test/error_strings_custom_functions_test.go
@@ -9,7 +9,7 @@ import (
 
 func TestErrorStringsWithCustomFunctions(t *testing.T) {
 	args := []any{"pkgErrors.Wrap"}
-	testRule(t, "error-strings-with-custom-functions", &rule.ErrorStringsRule{}, &lint.RuleConfig{
+	testRule(t, "error_strings_with_custom_functions", &rule.ErrorStringsRule{}, &lint.RuleConfig{
 		Arguments: args,
 	})
 }
diff --git a/test/exported_test.go b/test/exported_test.go
index b028eb5..6e32345 100644
--- a/test/exported_test.go
+++ b/test/exported_test.go
@@ -10,29 +10,29 @@ import (
 func TestExportedWithDisableStutteringCheck(t *testing.T) {
 	args := []any{"disableStutteringCheck"}
 
-	testRule(t, "exported-issue-555", &rule.ExportedRule{}, &lint.RuleConfig{Arguments: args})
+	testRule(t, "exported_issue_555", &rule.ExportedRule{}, &lint.RuleConfig{Arguments: args})
 }
 
 func TestExportedWithChecksOnMethodsOfPrivateTypes(t *testing.T) {
 	args := []any{"checkPrivateReceivers"}
 
-	testRule(t, "exported-issue-552", &rule.ExportedRule{}, &lint.RuleConfig{Arguments: args})
+	testRule(t, "exported_issue_552", &rule.ExportedRule{}, &lint.RuleConfig{Arguments: args})
 }
 
 func TestExportedReplacingStuttersByRepetitive(t *testing.T) {
 	args := []any{"sayRepetitiveInsteadOfStutters"}
 
-	testRule(t, "exported-issue-519", &rule.ExportedRule{}, &lint.RuleConfig{Arguments: args})
+	testRule(t, "exported_issue_519", &rule.ExportedRule{}, &lint.RuleConfig{Arguments: args})
 }
 
 func TestCheckPublicInterfaceOption(t *testing.T) {
 	args := []any{"checkPublicInterface"}
 
-	testRule(t, "exported-issue-1002", &rule.ExportedRule{}, &lint.RuleConfig{Arguments: args})
+	testRule(t, "exported_issue_1002", &rule.ExportedRule{}, &lint.RuleConfig{Arguments: args})
 }
 
 func TestCheckDisablingOnDeclarationTypes(t *testing.T) {
 	args := []any{"disableChecksOnConstants", "disableChecksOnFunctions", "disableChecksOnMethods", "disableChecksOnTypes", "disableChecksOnVariables"}
 
-	testRule(t, "exported-issue-1045", &rule.ExportedRule{}, &lint.RuleConfig{Arguments: args})
+	testRule(t, "exported_issue_1045", &rule.ExportedRule{}, &lint.RuleConfig{Arguments: args})
 }
diff --git a/test/file-filter_test.go b/test/file_filter_test.go
similarity index 77%
rename from test/file-filter_test.go
rename to test/file_filter_test.go
index a73d311..6efdc31 100644
--- a/test/file-filter_test.go
+++ b/test/file_filter_test.go
@@ -21,16 +21,16 @@ func (tfr *TestFileFilterRule) Apply(*lint.File, lint.Arguments) []lint.Failure
 func TestFileExcludeFilterAtRuleLevel(t *testing.T) {
 	t.Run("is called if no excludes", func(t *testing.T) {
 		rule := &TestFileFilterRule{}
-		testRule(t, "file-to-exclude", rule, &lint.RuleConfig{})
+		testRule(t, "file_to_exclude", rule, &lint.RuleConfig{})
 		if !rule.WasApplied {
 			t.Fatal("should call rule if no excludes")
 		}
 	})
 	t.Run("is called if exclude not match", func(t *testing.T) {
 		rule := &TestFileFilterRule{}
-		cfg := &lint.RuleConfig{Exclude: []string{"no-matched.go"}}
+		cfg := &lint.RuleConfig{Exclude: []string{"no_matched.go"}}
 		cfg.Initialize()
-		testRule(t, "file-to-exclude", rule, cfg)
+		testRule(t, "file_to_exclude", rule, cfg)
 		if !rule.WasApplied {
 			t.Fatal("should call rule if no excludes")
 		}
@@ -38,9 +38,9 @@ func TestFileExcludeFilterAtRuleLevel(t *testing.T) {
 
 	t.Run("not called if exclude not match", func(t *testing.T) {
 		rule := &TestFileFilterRule{}
-		cfg := &lint.RuleConfig{Exclude: []string{"../testdata/file-to-exclude.go"}}
+		cfg := &lint.RuleConfig{Exclude: []string{"../testdata/file_to_exclude.go"}}
 		cfg.Initialize()
-		testRule(t, "file-to-exclude", rule, cfg)
+		testRule(t, "file_to_exclude", rule, cfg)
 		if rule.WasApplied {
 			t.Fatal("should not call rule if excluded")
 		}
diff --git a/test/file-header_test.go b/test/file_header_test.go
similarity index 56%
rename from test/file-header_test.go
rename to test/file_header_test.go
index 39a03a6..b340a96 100644
--- a/test/file-header_test.go
+++ b/test/file_header_test.go
@@ -8,27 +8,27 @@ import (
 )
 
 func TestLintFileHeader(t *testing.T) {
-	testRule(t, "lint-file-header1", &rule.FileHeaderRule{}, &lint.RuleConfig{
+	testRule(t, "lint_file_header1", &rule.FileHeaderRule{}, &lint.RuleConfig{
 		Arguments: []any{"foobar"},
 	})
 
-	testRule(t, "lint-file-header2", &rule.FileHeaderRule{}, &lint.RuleConfig{
+	testRule(t, "lint_file_header2", &rule.FileHeaderRule{}, &lint.RuleConfig{
 		Arguments: []any{"foobar"},
 	})
 
-	testRule(t, "lint-file-header3", &rule.FileHeaderRule{}, &lint.RuleConfig{
+	testRule(t, "lint_file_header3", &rule.FileHeaderRule{}, &lint.RuleConfig{
 		Arguments: []any{"foobar"},
 	})
 
-	testRule(t, "lint-file-header4", &rule.FileHeaderRule{}, &lint.RuleConfig{
+	testRule(t, "lint_file_header4", &rule.FileHeaderRule{}, &lint.RuleConfig{
 		Arguments: []any{"^\\sfoobar$"},
 	})
 
-	testRule(t, "lint-file-header5", &rule.FileHeaderRule{}, &lint.RuleConfig{
+	testRule(t, "lint_file_header5", &rule.FileHeaderRule{}, &lint.RuleConfig{
 		Arguments: []any{"^\\sfoo.*bar$"},
 	})
 
-	testRule(t, "lint-file-header6", &rule.FileHeaderRule{}, &lint.RuleConfig{
+	testRule(t, "lint_file_header6", &rule.FileHeaderRule{}, &lint.RuleConfig{
 		Arguments: []any{"foobar"},
 	})
 }
@@ -36,7 +36,7 @@ func TestLintFileHeader(t *testing.T) {
 func BenchmarkLintFileHeader(b *testing.B) {
 	var t *testing.T
 	for i := 0; i <= b.N; i++ {
-		testRule(t, "lint-file-header1", &rule.FileHeaderRule{}, &lint.RuleConfig{
+		testRule(t, "lint_file_header1", &rule.FileHeaderRule{}, &lint.RuleConfig{
 			Arguments: []any{"foobar"},
 		})
 	}
diff --git a/test/file-length-limit_test.go b/test/file_length_limit_test.go
similarity index 65%
rename from test/file-length-limit_test.go
rename to test/file_length_limit_test.go
index c000daa..40002e2 100644
--- a/test/file-length-limit_test.go
+++ b/test/file_length_limit_test.go
@@ -8,25 +8,25 @@ import (
 )
 
 func TestFileLengthLimit(t *testing.T) {
-	testRule(t, "file-length-limit-disabled", &rule.FileLengthLimitRule{}, &lint.RuleConfig{
+	testRule(t, "file_length_limit_disabled", &rule.FileLengthLimitRule{}, &lint.RuleConfig{
 		Arguments: []any{},
 	})
-	testRule(t, "file-length-limit-disabled", &rule.FileLengthLimitRule{}, &lint.RuleConfig{
+	testRule(t, "file_length_limit_disabled", &rule.FileLengthLimitRule{}, &lint.RuleConfig{
 		Arguments: []any{map[string]any{"max": int64(0)}},
 	})
-	testRule(t, "file-length-limit-disabled", &rule.FileLengthLimitRule{}, &lint.RuleConfig{
+	testRule(t, "file_length_limit_disabled", &rule.FileLengthLimitRule{}, &lint.RuleConfig{
 		Arguments: []any{map[string]any{"skipComments": true, "skipBlankLines": true}},
 	})
-	testRule(t, "file-length-limit-9", &rule.FileLengthLimitRule{}, &lint.RuleConfig{
+	testRule(t, "file_length_limit_9", &rule.FileLengthLimitRule{}, &lint.RuleConfig{
 		Arguments: []any{map[string]any{"max": int64(9)}},
 	})
-	testRule(t, "file-length-limit-7-skip-comments", &rule.FileLengthLimitRule{}, &lint.RuleConfig{
+	testRule(t, "file_length_limit_7_skip_comments", &rule.FileLengthLimitRule{}, &lint.RuleConfig{
 		Arguments: []any{map[string]any{"max": int64(7), "skipComments": true}},
 	})
-	testRule(t, "file-length-limit-6-skip-blank", &rule.FileLengthLimitRule{}, &lint.RuleConfig{
+	testRule(t, "file_length_limit_6_skip_blank", &rule.FileLengthLimitRule{}, &lint.RuleConfig{
 		Arguments: []any{map[string]any{"max": int64(6), "skipBlankLines": true}},
 	})
-	testRule(t, "file-length-limit-4-skip-comments-skip-blank", &rule.FileLengthLimitRule{}, &lint.RuleConfig{
+	testRule(t, "file_length_limit_4_skip_comments_skip_blank", &rule.FileLengthLimitRule{}, &lint.RuleConfig{
 		Arguments: []any{map[string]any{"max": int64(4), "skipComments": true, "skipBlankLines": true}},
 	})
 }
diff --git a/test/filename-format_test.go b/test/filename_format_test.go
similarity index 72%
rename from test/filename-format_test.go
rename to test/filename_format_test.go
index 2f0ef76..6cd364f 100644
--- a/test/filename-format_test.go
+++ b/test/filename_format_test.go
@@ -8,9 +8,9 @@ import (
 )
 
 func TestLintFilenameFormat(t *testing.T) {
-	testRule(t, "filename-ok-default", &rule.FilenameFormatRule{}, &lint.RuleConfig{})
+	testRule(t, "filename_ok_default", &rule.FilenameFormatRule{}, &lint.RuleConfig{})
 
-	testRule(t, "filenamе-with-non-ascii-char", &rule.FilenameFormatRule{}, &lint.RuleConfig{})
+	testRule(t, "filenamе_with_non_ascii_char", &rule.FilenameFormatRule{}, &lint.RuleConfig{})
 
 	testRule(t, "filename_with_underscores", &rule.FilenameFormatRule{}, &lint.RuleConfig{Arguments: []any{"^[A-Za-z][A-Za-z0-9]*.go$"}})
 }
diff --git a/test/flag-param_test.go b/test/flag_param_test.go
similarity index 68%
rename from test/flag-param_test.go
rename to test/flag_param_test.go
index 7042173..62bc242 100644
--- a/test/flag-param_test.go
+++ b/test/flag_param_test.go
@@ -7,5 +7,5 @@ import (
 )
 
 func TestFlagParam(t *testing.T) {
-	testRule(t, "flag-param", &rule.FlagParamRule{})
+	testRule(t, "flag_param", &rule.FlagParamRule{})
 }
diff --git a/test/function-length_test.go b/test/function_length_test.go
similarity index 69%
rename from test/function-length_test.go
rename to test/function_length_test.go
index 68e8a26..fb531a5 100644
--- a/test/function-length_test.go
+++ b/test/function_length_test.go
@@ -8,19 +8,19 @@ import (
 )
 
 func TestFuncLengthLimitsStatements(t *testing.T) {
-	testRule(t, "function-length1", &rule.FunctionLength{}, &lint.RuleConfig{
+	testRule(t, "function_length1", &rule.FunctionLength{}, &lint.RuleConfig{
 		Arguments: []any{int64(2), int64(100)},
 	})
 }
 
 func TestFuncLengthLimitsLines(t *testing.T) {
-	testRule(t, "function-length2", &rule.FunctionLength{}, &lint.RuleConfig{
+	testRule(t, "function_length2", &rule.FunctionLength{}, &lint.RuleConfig{
 		Arguments: []any{int64(100), int64(5)},
 	})
 }
 
 func TestFuncLengthLimitsDeactivated(t *testing.T) {
-	testRule(t, "function-length3", &rule.FunctionLength{}, &lint.RuleConfig{
+	testRule(t, "function_length3", &rule.FunctionLength{}, &lint.RuleConfig{
 		Arguments: []any{int64(0), int64(0)},
 	})
 }
diff --git a/test/function-result-limit_test.go b/test/function_result_limit_test.go
similarity index 76%
rename from test/function-result-limit_test.go
rename to test/function_result_limit_test.go
index ce5d1d5..7bcc41f 100644
--- a/test/function-result-limit_test.go
+++ b/test/function_result_limit_test.go
@@ -8,7 +8,7 @@ import (
 )
 
 func TestFunctionResultsLimit(t *testing.T) {
-	testRule(t, "function-result-limit", &rule.FunctionResultsLimitRule{}, &lint.RuleConfig{
+	testRule(t, "function_result_limit", &rule.FunctionResultsLimitRule{}, &lint.RuleConfig{
 		Arguments: []any{int64(3)},
 	})
 }
diff --git a/test/get-return_test.go b/test/get_return_test.go
similarity index 68%
rename from test/get-return_test.go
rename to test/get_return_test.go
index 0b320dd..b0391a3 100644
--- a/test/get-return_test.go
+++ b/test/get_return_test.go
@@ -7,5 +7,5 @@ import (
 )
 
 func TestGetReturn(t *testing.T) {
-	testRule(t, "get-return", &rule.GetReturnRule{})
+	testRule(t, "get_return", &rule.GetReturnRule{})
 }
diff --git a/test/identical-branches_test.go b/test/identical_branches_test.go
similarity index 69%
rename from test/identical-branches_test.go
rename to test/identical_branches_test.go
index 0d1a6c5..a0fc161 100644
--- a/test/identical-branches_test.go
+++ b/test/identical_branches_test.go
@@ -8,5 +8,5 @@ import (
 
 // IdenticalBranches rule.
 func TestIdenticalBranches(t *testing.T) {
-	testRule(t, "identical-branches", &rule.IdenticalBranchesRule{})
+	testRule(t, "identical_branches", &rule.IdenticalBranchesRule{})
 }
diff --git a/test/if-return_test.go b/test/if_return_test.go
similarity index 73%
rename from test/if-return_test.go
rename to test/if_return_test.go
index 161c9f1..2e7348b 100644
--- a/test/if-return_test.go
+++ b/test/if_return_test.go
@@ -8,5 +8,5 @@ import (
 
 // TestIfReturn rule.
 func TestIfReturn(t *testing.T) {
-	testRule(t, "if-return", &rule.IfReturnRule{})
+	testRule(t, "if_return", &rule.IfReturnRule{})
 }
diff --git a/test/import-alias-naming_test.go b/test/import_alias_naming_test.go
similarity index 72%
rename from test/import-alias-naming_test.go
rename to test/import_alias_naming_test.go
index a4782c2..5693608 100644
--- a/test/import-alias-naming_test.go
+++ b/test/import_alias_naming_test.go
@@ -8,8 +8,8 @@ import (
 )
 
 func TestImportAliasNaming(t *testing.T) {
-	testRule(t, "import-alias-naming", &rule.ImportAliasNamingRule{})
-	testRule(t, "import-alias-naming", &rule.ImportAliasNamingRule{}, &lint.RuleConfig{
+	testRule(t, "import_alias_naming", &rule.ImportAliasNamingRule{})
+	testRule(t, "import_alias_naming", &rule.ImportAliasNamingRule{}, &lint.RuleConfig{
 		Arguments: lint.Arguments{
 			map[string]any{},
 		},
@@ -17,13 +17,13 @@ func TestImportAliasNaming(t *testing.T) {
 }
 
 func TestImportAliasNaming_CustomConfig(t *testing.T) {
-	testRule(t, "import-alias-naming-custom-config", &rule.ImportAliasNamingRule{}, &lint.RuleConfig{
+	testRule(t, "import_alias_naming_custom_config", &rule.ImportAliasNamingRule{}, &lint.RuleConfig{
 		Arguments: []any{`^[a-z]+$`},
 	})
 }
 
 func TestImportAliasNaming_CustomConfigWithMultipleRules(t *testing.T) {
-	testRule(t, "import-alias-naming-custom-config-with-multiple-values", &rule.ImportAliasNamingRule{}, &lint.RuleConfig{
+	testRule(t, "import_alias_naming_custom_config_with_multiple_values", &rule.ImportAliasNamingRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"allowRegex": `^[a-z][a-z0-9]*$`,
@@ -34,7 +34,7 @@ func TestImportAliasNaming_CustomConfigWithMultipleRules(t *testing.T) {
 }
 
 func TestImportAliasNaming_CustomConfigWithOnlyDeny(t *testing.T) {
-	testRule(t, "import-alias-naming-custom-config-with-only-deny", &rule.ImportAliasNamingRule{}, &lint.RuleConfig{
+	testRule(t, "import_alias_naming_custom_config_with_only_deny", &rule.ImportAliasNamingRule{}, &lint.RuleConfig{
 		Arguments: []any{
 			map[string]any{
 				"denyRegex": `^((v\d+)|(v\d+alpha\d+))$`,
diff --git a/test/import-shadowing_test.go b/test/import_shadowing_test.go
similarity index 64%
rename from test/import-shadowing_test.go
rename to test/import_shadowing_test.go
index 12e64f2..0c74e1b 100644
--- a/test/import-shadowing_test.go
+++ b/test/import_shadowing_test.go
@@ -7,5 +7,5 @@ import (
 )
 
 func TestImportShadowing(t *testing.T) {
-	testRule(t, "import-shadowing", &rule.ImportShadowingRule{})
+	testRule(t, "import_shadowing", &rule.ImportShadowingRule{})
 }
diff --git a/test/import-blocklist_test.go b/test/imports_blocklist_test.go
similarity index 78%
rename from test/import-blocklist_test.go
rename to test/imports_blocklist_test.go
index bbd8ba4..e5a20f1 100644
--- a/test/import-blocklist_test.go
+++ b/test/imports_blocklist_test.go
@@ -10,7 +10,7 @@ import (
 func TestImportsBlocklistOriginal(t *testing.T) {
 	args := []any{"crypto/md5", "crypto/sha1"}
 
-	testRule(t, "imports-blocklist-original", &rule.ImportsBlocklistRule{}, &lint.RuleConfig{
+	testRule(t, "imports_blocklist_original", &rule.ImportsBlocklistRule{}, &lint.RuleConfig{
 		Arguments: args,
 	})
 }
@@ -18,7 +18,7 @@ func TestImportsBlocklistOriginal(t *testing.T) {
 func TestImportsBlocklist(t *testing.T) {
 	args := []any{"github.com/full/match", "wildcard/**/between", "wildcard/backward/**", "**/wildcard/forward", "full"}
 
-	testRule(t, "imports-blocklist", &rule.ImportsBlocklistRule{}, &lint.RuleConfig{
+	testRule(t, "imports_blocklist", &rule.ImportsBlocklistRule{}, &lint.RuleConfig{
 		Arguments: args,
 	})
 }
@@ -27,7 +27,7 @@ func BenchmarkImportsBlocklist(b *testing.B) {
 	args := []any{"github.com/full/match", "wildcard/**/between", "wildcard/backward/**", "**/wildcard/forward", "full"}
 	var t *testing.T
 	for i := 0; i <= b.N; i++ {
-		testRule(t, "imports-blocklist", &rule.ImportsBlocklistRule{}, &lint.RuleConfig{
+		testRule(t, "imports_blocklist", &rule.ImportsBlocklistRule{}, &lint.RuleConfig{
 			Arguments: args,
 		})
 	}
diff --git a/test/issue1100_test.go b/test/issue1100_test.go
new file mode 100644
index 0000000..4e3f9f6
--- /dev/null
+++ b/test/issue1100_test.go
@@ -0,0 +1,22 @@
+package test
+
+import (
+	"testing"
+
+	"github.com/mgechev/revive/lint"
+	"github.com/mgechev/revive/rule"
+)
+
+func TestIssue1100(t *testing.T) {
+	args := []any{map[string]any{
+		"maxLitCount": "2",
+		"allowStrs":   "\"\"",
+		"allowInts":   "0,1,2",
+		"allowFloats": "0.0,1.0",
+		"ignoreFuncs": "os\\.(CreateFile|WriteFile|Chmod|FindProcess),\\.Println,ignoredFunc,\\.Info",
+	}}
+
+	testRule(t, "goUnknown/issue1100", &rule.AddConstantRule{}, &lint.RuleConfig{
+		Arguments: args,
+	})
+}
diff --git a/test/json-data-format_test.go b/test/json_data_format_test.go
similarity index 64%
rename from test/json-data-format_test.go
rename to test/json_data_format_test.go
index 41b154c..b81a6f5 100644
--- a/test/json-data-format_test.go
+++ b/test/json_data_format_test.go
@@ -8,9 +8,9 @@ import (
 )
 
 func TestJsonDataFormat(t *testing.T) {
-	testRule(t, "json-data-format-atomic", &rule.AtomicRule{})
+	testRule(t, "json_data_format_atomic", &rule.AtomicRule{})
 }
 
 func TestJsonDataFormatVarNaming(t *testing.T) {
-	testRule(t, "json-data-format-var-naming", &rule.VarNamingRule{}, &lint.RuleConfig{})
+	testRule(t, "json_data_format_var_naming", &rule.VarNamingRule{}, &lint.RuleConfig{})
 }
diff --git a/test/line-length-limit_test.go b/test/line_length_limit_test.go
similarity index 75%
rename from test/line-length-limit_test.go
rename to test/line_length_limit_test.go
index 4e81372..c29e19b 100644
--- a/test/line-length-limit_test.go
+++ b/test/line_length_limit_test.go
@@ -8,7 +8,7 @@ import (
 )
 
 func TestLineLengthLimit(t *testing.T) {
-	testRule(t, "line-length-limit", &rule.LineLengthLimitRule{}, &lint.RuleConfig{
+	testRule(t, "line_length_limit", &rule.LineLengthLimitRule{}, &lint.RuleConfig{
 		Arguments: []any{int64(100)},
 	})
 }
diff --git a/test/max-control-nesting_test.go b/test/max_control_nesting_test.go
similarity index 76%
rename from test/max-control-nesting_test.go
rename to test/max_control_nesting_test.go
index cbb0beb..d6906ba 100644
--- a/test/max-control-nesting_test.go
+++ b/test/max_control_nesting_test.go
@@ -8,7 +8,7 @@ import (
 )
 
 func TestMaxControlNesting(t *testing.T) {
-	testRule(t, "max-control-nesting", &rule.MaxControlNestingRule{}, &lint.RuleConfig{
+	testRule(t, "max_control_nesting", &rule.MaxControlNestingRule{}, &lint.RuleConfig{
 		Arguments: []any{int64(2)}},
 	)
 }
diff --git a/test/max-public-structs_test.go b/test/max_public_structs_test.go
similarity index 76%
rename from test/max-public-structs_test.go
rename to test/max_public_structs_test.go
index 54a1d38..22c7455 100644
--- a/test/max-public-structs_test.go
+++ b/test/max_public_structs_test.go
@@ -8,7 +8,7 @@ import (
 )
 
 func TestMaxPublicStructs(t *testing.T) {
-	testRule(t, "max-public-structs", &rule.MaxPublicStructsRule{}, &lint.RuleConfig{
+	testRule(t, "max_public_structs", &rule.MaxPublicStructsRule{}, &lint.RuleConfig{
 		Arguments: []any{int64(1)},
 	})
 }
diff --git a/test/modifies-param_test.go b/test/modifies_param_test.go
similarity index 70%
rename from test/modifies-param_test.go
rename to test/modifies_param_test.go
index c77a300..d6ab7c9 100644
--- a/test/modifies-param_test.go
+++ b/test/modifies_param_test.go
@@ -8,5 +8,5 @@ import (
 
 // TestModifiesParam rule.
 func TestModifiesParam(t *testing.T) {
-	testRule(t, "modifies-param", &rule.ModifiesParamRule{})
+	testRule(t, "modifies_param", &rule.ModifiesParamRule{})
 }
diff --git a/test/modifies-value-receiver_test.go b/test/modifies_value_receiver_test.go
similarity index 64%
rename from test/modifies-value-receiver_test.go
rename to test/modifies_value_receiver_test.go
index b16f535..3d68a10 100644
--- a/test/modifies-value-receiver_test.go
+++ b/test/modifies_value_receiver_test.go
@@ -7,5 +7,5 @@ import (
 )
 
 func TestModifiesValRec(t *testing.T) {
-	testRule(t, "modifies-value-receiver", &rule.ModifiesValRecRule{})
+	testRule(t, "modifies_value_receiver", &rule.ModifiesValRecRule{})
 }
diff --git a/test/nested-structs_test.go b/test/nested_structs_test.go
similarity index 71%
rename from test/nested-structs_test.go
rename to test/nested_structs_test.go
index 733521a..71f2058 100644
--- a/test/nested-structs_test.go
+++ b/test/nested_structs_test.go
@@ -8,5 +8,5 @@ import (
 )
 
 func TestNestedStructs(t *testing.T) {
-	testRule(t, "nested-structs", &rule.NestedStructs{}, &lint.RuleConfig{})
+	testRule(t, "nested_structs", &rule.NestedStructs{}, &lint.RuleConfig{})
 }
diff --git a/test/optimize-operands-order_test.go b/test/optimize_operands_order_test.go
similarity index 80%
rename from test/optimize-operands-order_test.go
rename to test/optimize_operands_order_test.go
index e8d50b3..431a679 100644
--- a/test/optimize-operands-order_test.go
+++ b/test/optimize_operands_order_test.go
@@ -9,5 +9,5 @@ import (
 
 // Test that left and right side of Binary operators (only AND, OR) are swapable
 func TestOptimizeOperandsOrder(t *testing.T) {
-	testRule(t, "optimize-operands-order", &rule.OptimizeOperandsOrderRule{}, &lint.RuleConfig{})
+	testRule(t, "optimize_operands_order", &rule.OptimizeOperandsOrderRule{}, &lint.RuleConfig{})
 }
diff --git a/test/range-val-address_test.go b/test/range_val_address_test.go
similarity index 65%
rename from test/range-val-address_test.go
rename to test/range_val_address_test.go
index 821187c..5fa67a1 100644
--- a/test/range-val-address_test.go
+++ b/test/range_val_address_test.go
@@ -8,9 +8,9 @@ import (
 )
 
 func TestRangeValAddress(t *testing.T) {
-	testRule(t, "range-val-address", &rule.RangeValAddress{}, &lint.RuleConfig{})
+	testRule(t, "range_val_address", &rule.RangeValAddress{}, &lint.RuleConfig{})
 }
 
 func TestRangeValAddressAfterGo1_22(t *testing.T) {
-	testRule(t, "go1.22/range-val-address", &rule.RangeValAddress{}, &lint.RuleConfig{})
+	testRule(t, "go1.22/range_val_address", &rule.RangeValAddress{}, &lint.RuleConfig{})
 }
diff --git a/test/range-val-in-closure_test.go b/test/range_val_in_closure_test.go
similarity index 67%
rename from test/range-val-in-closure_test.go
rename to test/range_val_in_closure_test.go
index a84ce08..fe30107 100644
--- a/test/range-val-in-closure_test.go
+++ b/test/range_val_in_closure_test.go
@@ -8,9 +8,9 @@ import (
 )
 
 func TestRangeValInClosure(t *testing.T) {
-	testRule(t, "range-val-in-closure", &rule.RangeValInClosureRule{}, &lint.RuleConfig{})
+	testRule(t, "range_val_in_closure", &rule.RangeValInClosureRule{}, &lint.RuleConfig{})
 }
 
 func TestRangeValInClosureAfterGo1_22(t *testing.T) {
-	testRule(t, "go1.22/range-val-in-closure", &rule.RangeValInClosureRule{}, &lint.RuleConfig{})
+	testRule(t, "go1.22/range_val_in_closure", &rule.RangeValInClosureRule{}, &lint.RuleConfig{})
 }
diff --git a/test/receiver-naming_test.go b/test/receiver_naming_test.go
similarity index 78%
rename from test/receiver-naming_test.go
rename to test/receiver_naming_test.go
index bbab89a..2c7b238 100644
--- a/test/receiver-naming_test.go
+++ b/test/receiver_naming_test.go
@@ -12,13 +12,13 @@ func TestReceiverNamingTypeParams(t *testing.T) {
 	if !typeparams.Enabled() {
 		t.Skip("type parameters are not enabled in the current build environment")
 	}
-	testRule(t, "receiver-naming-issue-669", &rule.ReceiverNamingRule{})
+	testRule(t, "receiver_naming_issue_669", &rule.ReceiverNamingRule{})
 }
 
 func TestReceiverNamingMaxLength(t *testing.T) {
 	args := []any{map[string]any{
 		"maxLength": int64(2),
 	}}
-	testRule(t, "receiver-naming-issue-1040", &rule.ReceiverNamingRule{},
+	testRule(t, "receiver_naming_issue_1040", &rule.ReceiverNamingRule{},
 		&lint.RuleConfig{Arguments: args})
 }
diff --git a/test/redefines-builtin-id_test.go b/test/redefines_builtin_id_test.go
similarity index 63%
rename from test/redefines-builtin-id_test.go
rename to test/redefines_builtin_id_test.go
index 18da663..68bb94b 100644
--- a/test/redefines-builtin-id_test.go
+++ b/test/redefines_builtin_id_test.go
@@ -8,9 +8,9 @@ import (
 
 // Tests RedefinesBuiltinID rule.
 func TestRedefinesBuiltinID(t *testing.T) {
-	testRule(t, "redefines-builtin-id", &rule.RedefinesBuiltinIDRule{})
+	testRule(t, "redefines_builtin_id", &rule.RedefinesBuiltinIDRule{})
 }
 
 func TestRedefinesBuiltinIDAfterGo1_21(t *testing.T) {
-	testRule(t, "go1.21/redefines-builtin-id", &rule.RedefinesBuiltinIDRule{})
+	testRule(t, "go1.21/redefines_builtin_id", &rule.RedefinesBuiltinIDRule{})
 }
diff --git a/test/redundant-import-alias_test.go b/test/redundant_import_alias_test.go
similarity index 71%
rename from test/redundant-import-alias_test.go
rename to test/redundant_import_alias_test.go
index e7bff5f..eeb3e2e 100644
--- a/test/redundant-import-alias_test.go
+++ b/test/redundant_import_alias_test.go
@@ -7,5 +7,5 @@ import (
 
 // TestRedundantImportAlias rule.
 func TestRedundantImportAlias(t *testing.T) {
-	testRule(t, "redundant-import-alias", &rule.RedundantImportAlias{})
+	testRule(t, "redundant_import_alias", &rule.RedundantImportAlias{})
 }
diff --git a/test/string-format_test.go b/test/string_format_test.go
similarity index 97%
rename from test/string-format_test.go
rename to test/string_format_test.go
index 2ca1bd1..f83a99b 100644
--- a/test/string-format_test.go
+++ b/test/string_format_test.go
@@ -8,7 +8,7 @@ import (
 )
 
 func TestStringFormat(t *testing.T) {
-	testRule(t, "string-format", &rule.StringFormatRule{}, &lint.RuleConfig{
+	testRule(t, "string_format", &rule.StringFormatRule{}, &lint.RuleConfig{
 		Arguments: lint.Arguments{
 			[]any{
 				"stringFormatMethod1", // The first argument is checked by default
@@ -173,7 +173,7 @@ func TestStringFormatArgumentParsing(t *testing.T) {
 }
 
 func TestStringFormatDuplicatedStrings(t *testing.T) {
-	testRule(t, "string-format-issue-1063", &rule.StringFormatRule{}, &lint.RuleConfig{
+	testRule(t, "string_format_issue_1063", &rule.StringFormatRule{}, &lint.RuleConfig{
 		Arguments: lint.Arguments{[]any{
 			"fmt.Errorf[0],errors.New[0]",
 			"/^([^A-Z]|$)/",
diff --git a/test/string-of-int_test.go b/test/string_of_int_test.go
similarity index 70%
rename from test/string-of-int_test.go
rename to test/string_of_int_test.go
index dc756d8..c6e2f0c 100644
--- a/test/string-of-int_test.go
+++ b/test/string_of_int_test.go
@@ -8,5 +8,5 @@ import (
 
 // String-of-int rule.
 func TestStringOfInt(t *testing.T) {
-	testRule(t, "string-of-int", &rule.StringOfIntRule{})
+	testRule(t, "string_of_int", &rule.StringOfIntRule{})
 }
diff --git a/test/struct-tag_test.go b/test/struct_tag_test.go
similarity index 69%
rename from test/struct-tag_test.go
rename to test/struct_tag_test.go
index 18e8fb9..44381e3 100644
--- a/test/struct-tag_test.go
+++ b/test/struct_tag_test.go
@@ -9,11 +9,11 @@ import (
 
 // TestStructTag tests struct-tag rule
 func TestStructTag(t *testing.T) {
-	testRule(t, "struct-tag", &rule.StructTagRule{})
+	testRule(t, "struct_tag", &rule.StructTagRule{})
 }
 
 func TestStructTagWithUserOptions(t *testing.T) {
-	testRule(t, "struct-tag-useroptions", &rule.StructTagRule{}, &lint.RuleConfig{
+	testRule(t, "struct_tag_user_options", &rule.StructTagRule{}, &lint.RuleConfig{
 		Arguments: []any{"json,inline,outline", "bson,gnu"},
 	})
 }
diff --git a/test/superfluous-else_test.go b/test/superfluous_else_test.go
similarity index 69%
rename from test/superfluous-else_test.go
rename to test/superfluous_else_test.go
index 1916938..88815c8 100644
--- a/test/superfluous-else_test.go
+++ b/test/superfluous_else_test.go
@@ -10,6 +10,6 @@ import (
 
 // TestSuperfluousElse rule.
 func TestSuperfluousElse(t *testing.T) {
-	testRule(t, "superfluous-else", &rule.SuperfluousElseRule{})
-	testRule(t, "superfluous-else-scope", &rule.SuperfluousElseRule{}, &lint.RuleConfig{Arguments: []any{ifelse.PreserveScope}})
+	testRule(t, "superfluous_else", &rule.SuperfluousElseRule{})
+	testRule(t, "superfluous_else_scope", &rule.SuperfluousElseRule{}, &lint.RuleConfig{Arguments: []any{ifelse.PreserveScope}})
 }
diff --git a/test/time-equal_test.go b/test/time_equal_test.go
similarity index 72%
rename from test/time-equal_test.go
rename to test/time_equal_test.go
index 7e54269..8b2a98a 100644
--- a/test/time-equal_test.go
+++ b/test/time_equal_test.go
@@ -8,5 +8,5 @@ import (
 
 // TestTimeEqual rule.
 func TestTimeEqual(t *testing.T) {
-	testRule(t, "time-equal", &rule.TimeEqualRule{})
+	testRule(t, "time_equal", &rule.TimeEqualRule{})
 }
diff --git a/test/time-naming_test.go b/test/time_naming_test.go
similarity index 72%
rename from test/time-naming_test.go
rename to test/time_naming_test.go
index 3b241d1..be5fbf3 100644
--- a/test/time-naming_test.go
+++ b/test/time_naming_test.go
@@ -8,5 +8,5 @@ import (
 
 // TestTimeNamingRule rule.
 func TestTimeNaming(t *testing.T) {
-	testRule(t, "time-naming", &rule.TimeNamingRule{})
+	testRule(t, "time_naming", &rule.TimeNamingRule{})
 }
diff --git a/test/unchecked_type_assertion_test.go b/test/unchecked_type_assertion_test.go
index 454923c..8ae240f 100644
--- a/test/unchecked_type_assertion_test.go
+++ b/test/unchecked_type_assertion_test.go
@@ -8,7 +8,7 @@ import (
 )
 
 func TestUncheckedDynamicCast(t *testing.T) {
-	testRule(t, "unchecked-type-assertion", &rule.UncheckedTypeAssertionRule{})
+	testRule(t, "unchecked_type_assertion", &rule.UncheckedTypeAssertionRule{})
 }
 
 func TestUncheckedDynamicCastWithAcceptIgnored(t *testing.T) {
@@ -16,5 +16,5 @@ func TestUncheckedDynamicCastWithAcceptIgnored(t *testing.T) {
 		"acceptIgnoredAssertionResult": true,
 	}}
 
-	testRule(t, "unchecked-type-assertion-accept-ignored", &rule.UncheckedTypeAssertionRule{}, &lint.RuleConfig{Arguments: args})
+	testRule(t, "unchecked_type_assertion_accept_ignored", &rule.UncheckedTypeAssertionRule{}, &lint.RuleConfig{Arguments: args})
 }
diff --git a/test/unconditional-recursion_test.go b/test/unconditional_recursion_test.go
similarity index 67%
rename from test/unconditional-recursion_test.go
rename to test/unconditional_recursion_test.go
index d47d29c..d55b3a8 100644
--- a/test/unconditional-recursion_test.go
+++ b/test/unconditional_recursion_test.go
@@ -7,5 +7,5 @@ import (
 )
 
 func TestUnconditionalRecursion(t *testing.T) {
-	testRule(t, "unconditional-recursion", &rule.UnconditionalRecursionRule{})
+	testRule(t, "unconditional_recursion", &rule.UnconditionalRecursionRule{})
 }
diff --git a/test/unexported_naming_test.go b/test/unexported_naming_test.go
new file mode 100644
index 0000000..3020ae1
--- /dev/null
+++ b/test/unexported_naming_test.go
@@ -0,0 +1,11 @@
+package test
+
+import (
+	"testing"
+
+	"github.com/mgechev/revive/rule"
+)
+
+func TestUnexportedNaming(t *testing.T) {
+	testRule(t, "unexported_naming", &rule.UnexportedNamingRule{})
+}
diff --git a/test/unhandled-error_test.go b/test/unhandled_error_test.go
similarity index 77%
rename from test/unhandled-error_test.go
rename to test/unhandled_error_test.go
index c341fe1..606f4a1 100644
--- a/test/unhandled-error_test.go
+++ b/test/unhandled_error_test.go
@@ -8,7 +8,7 @@ import (
 )
 
 func TestUnhandledError(t *testing.T) {
-	testRule(t, "unhandled-error", &rule.UnhandledErrorRule{})
+	testRule(t, "unhandled_error", &rule.UnhandledErrorRule{})
 }
 
 func TestUnhandledErrorWithIgnoreList(t *testing.T) {
@@ -21,5 +21,5 @@ func TestUnhandledErrorWithIgnoreList(t *testing.T) {
 		`fixtures\.unhandledErrorStruct2\.reterr`,
 	}
 
-	testRule(t, "unhandled-error-w-ignorelist", &rule.UnhandledErrorRule{}, &lint.RuleConfig{Arguments: args})
+	testRule(t, "unhandled_error_w_ignorelist", &rule.UnhandledErrorRule{}, &lint.RuleConfig{Arguments: args})
 }
diff --git a/test/unnecessary-stmt_test.go b/test/unnecessary_stmt_test.go
similarity index 69%
rename from test/unnecessary-stmt_test.go
rename to test/unnecessary_stmt_test.go
index 577a8aa..79c27ba 100644
--- a/test/unnecessary-stmt_test.go
+++ b/test/unnecessary_stmt_test.go
@@ -8,5 +8,5 @@ import (
 
 // TestUnnecessaryStmt rule.
 func TestUnnecessaryStmt(t *testing.T) {
-	testRule(t, "unnecessary-stmt", &rule.UnnecessaryStmtRule{})
+	testRule(t, "unnecessary_stmt", &rule.UnnecessaryStmtRule{})
 }
diff --git a/test/unreachable-code_test.go b/test/unreachable_code_test.go
similarity index 64%
rename from test/unreachable-code_test.go
rename to test/unreachable_code_test.go
index e8c3de9..7442153 100644
--- a/test/unreachable-code_test.go
+++ b/test/unreachable_code_test.go
@@ -7,5 +7,5 @@ import (
 )
 
 func TestUnreachableCode(t *testing.T) {
-	testRule(t, "unreachable-code", &rule.UnreachableCodeRule{})
+	testRule(t, "unreachable_code", &rule.UnreachableCodeRule{})
 }
diff --git a/test/unused-param_test.go b/test/unused_param_test.go
similarity index 65%
rename from test/unused-param_test.go
rename to test/unused_param_test.go
index da19ea5..6a98c9b 100644
--- a/test/unused-param_test.go
+++ b/test/unused_param_test.go
@@ -8,8 +8,8 @@ import (
 )
 
 func TestUnusedParam(t *testing.T) {
-	testRule(t, "unused-param", &rule.UnusedParamRule{})
-	testRule(t, "unused-param-custom-regex", &rule.UnusedParamRule{}, &lint.RuleConfig{Arguments: []any{
+	testRule(t, "unused_param", &rule.UnusedParamRule{})
+	testRule(t, "unused_param_custom_regex", &rule.UnusedParamRule{}, &lint.RuleConfig{Arguments: []any{
 		map[string]any{"allowRegex": "^xxx"},
 	}})
 }
@@ -17,6 +17,6 @@ func TestUnusedParam(t *testing.T) {
 func BenchmarkUnusedParam(b *testing.B) {
 	var t *testing.T
 	for i := 0; i <= b.N; i++ {
-		testRule(t, "unused-param", &rule.UnusedParamRule{})
+		testRule(t, "unused_param", &rule.UnusedParamRule{})
 	}
 }
diff --git a/test/unused-receiver_test.go b/test/unused_receiver_test.go
similarity index 65%
rename from test/unused-receiver_test.go
rename to test/unused_receiver_test.go
index af402fc..1f7ce32 100644
--- a/test/unused-receiver_test.go
+++ b/test/unused_receiver_test.go
@@ -8,8 +8,8 @@ import (
 )
 
 func TestUnusedReceiver(t *testing.T) {
-	testRule(t, "unused-receiver", &rule.UnusedReceiverRule{})
-	testRule(t, "unused-receiver-custom-regex", &rule.UnusedReceiverRule{}, &lint.RuleConfig{Arguments: []any{
+	testRule(t, "unused_receiver", &rule.UnusedReceiverRule{})
+	testRule(t, "unused_receiver_custom_regex", &rule.UnusedReceiverRule{}, &lint.RuleConfig{Arguments: []any{
 		map[string]any{"allowRegex": "^xxx"},
 	}})
 }
diff --git a/test/unxeported-naming_test.go b/test/unxeported-naming_test.go
deleted file mode 100644
index d689bef..0000000
--- a/test/unxeported-naming_test.go
+++ /dev/null
@@ -1,11 +0,0 @@
-package test
-
-import (
-	"testing"
-
-	"github.com/mgechev/revive/rule"
-)
-
-func TestUnexportednaming(t *testing.T) {
-	testRule(t, "unexported-naming", &rule.UnexportedNamingRule{})
-}
diff --git a/test/use-any_test.go b/test/use_any_test.go
similarity index 70%
rename from test/use-any_test.go
rename to test/use_any_test.go
index b1183ec..6748f8c 100644
--- a/test/use-any_test.go
+++ b/test/use_any_test.go
@@ -7,5 +7,5 @@ import (
 )
 
 func TestUseAny(t *testing.T) {
-	testRule(t, "use-any", &rule.UseAnyRule{})
+	testRule(t, "use_any", &rule.UseAnyRule{})
 }
diff --git a/test/useless-break_test.go b/test/useless_break_test.go
similarity index 72%
rename from test/useless-break_test.go
rename to test/useless_break_test.go
index d77dfc3..439bca5 100644
--- a/test/useless-break_test.go
+++ b/test/useless_break_test.go
@@ -8,5 +8,5 @@ import (
 
 // UselessBreak rule.
 func TestUselessBreak(t *testing.T) {
-	testRule(t, "useless-break", &rule.UselessBreak{})
+	testRule(t, "useless_break", &rule.UselessBreak{})
 }
diff --git a/test/var-naming_test.go b/test/var-naming_test.go
deleted file mode 100644
index 9347385..0000000
--- a/test/var-naming_test.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package test
-
-import (
-	"testing"
-
-	"github.com/mgechev/revive/lint"
-	"github.com/mgechev/revive/rule"
-)
-
-func TestVarNaming(t *testing.T) {
-	testRule(t, "var-naming", &rule.VarNamingRule{}, &lint.RuleConfig{
-		Arguments: []any{[]any{"ID"}, []any{"VM"}},
-	})
-
-	testRule(t, "var-naming_test", &rule.VarNamingRule{}, &lint.RuleConfig{})
-
-	testRule(t, "var-naming_upperCaseConst-false", &rule.VarNamingRule{}, &lint.RuleConfig{})
-	testRule(t, "var-naming_upperCaseConst-true", &rule.VarNamingRule{}, &lint.RuleConfig{
-		Arguments: []any{[]any{}, []any{}, []any{map[string]any{"upperCaseConst": true}}},
-	})
-
-	testRule(t, "var-naming_skipPackageNameChecks-false", &rule.VarNamingRule{}, &lint.RuleConfig{})
-	testRule(t, "var-naming_skipPackageNameChecks-true", &rule.VarNamingRule{}, &lint.RuleConfig{
-		Arguments: []any{[]any{}, []any{}, []any{map[string]any{"skipPackageNameChecks": true}}},
-	})
-}
diff --git a/test/var_naming_test.go b/test/var_naming_test.go
new file mode 100644
index 0000000..c523047
--- /dev/null
+++ b/test/var_naming_test.go
@@ -0,0 +1,26 @@
+package test
+
+import (
+	"testing"
+
+	"github.com/mgechev/revive/lint"
+	"github.com/mgechev/revive/rule"
+)
+
+func TestVarNaming(t *testing.T) {
+	testRule(t, "var_naming", &rule.VarNamingRule{}, &lint.RuleConfig{
+		Arguments: []any{[]any{"ID"}, []any{"VM"}},
+	})
+
+	testRule(t, "var_naming_test", &rule.VarNamingRule{}, &lint.RuleConfig{})
+
+	testRule(t, "var_naming_upper_case_const_false", &rule.VarNamingRule{}, &lint.RuleConfig{})
+	testRule(t, "var_naming_upper_case_const_true", &rule.VarNamingRule{}, &lint.RuleConfig{
+		Arguments: []any{[]any{}, []any{}, []any{map[string]any{"upperCaseConst": true}}},
+	})
+
+	testRule(t, "var_naming_skip_package_name_checks_false", &rule.VarNamingRule{}, &lint.RuleConfig{})
+	testRule(t, "var_naming_skip_package_name_checks_true", &rule.VarNamingRule{}, &lint.RuleConfig{
+		Arguments: []any{[]any{}, []any{}, []any{map[string]any{"skipPackageNameChecks": true}}},
+	})
+}
diff --git a/test/waitgroup-by-value_test.go b/test/waitgroup_by_value_test.go
similarity index 64%
rename from test/waitgroup-by-value_test.go
rename to test/waitgroup_by_value_test.go
index 398ac9a..6b268ae 100644
--- a/test/waitgroup-by-value_test.go
+++ b/test/waitgroup_by_value_test.go
@@ -7,5 +7,5 @@ import (
 )
 
 func TestWaitGroupByValue(t *testing.T) {
-	testRule(t, "waitgroup-by-value", &rule.WaitGroupByValueRule{})
+	testRule(t, "waitgroup_by_value", &rule.WaitGroupByValueRule{})
 }
diff --git a/testdata/add-constant.go b/testdata/add_constant.go
similarity index 100%
rename from testdata/add-constant.go
rename to testdata/add_constant.go
diff --git a/testdata/argument-limit.go b/testdata/argument_limit.go
similarity index 100%
rename from testdata/argument-limit.go
rename to testdata/argument_limit.go
diff --git a/testdata/banned-characters.go b/testdata/banned_characters.go
similarity index 100%
rename from testdata/banned-characters.go
rename to testdata/banned_characters.go
diff --git a/testdata/bare-return.go b/testdata/bare_return.go
similarity index 100%
rename from testdata/bare-return.go
rename to testdata/bare_return.go
diff --git a/testdata/bool-literal-in-expr.go b/testdata/bool_literal_in_expr.go
similarity index 100%
rename from testdata/bool-literal-in-expr.go
rename to testdata/bool_literal_in_expr.go
diff --git a/testdata/call-to-gc.go b/testdata/call_to_gc.go
similarity index 100%
rename from testdata/call-to-gc.go
rename to testdata/call_to_gc.go
diff --git a/testdata/cognitive-complexity.go b/testdata/cognitive_complexity.go
similarity index 100%
rename from testdata/cognitive-complexity.go
rename to testdata/cognitive_complexity.go
diff --git a/testdata/comment-spacings.go b/testdata/comment_spacings.go
similarity index 100%
rename from testdata/comment-spacings.go
rename to testdata/comment_spacings.go
diff --git a/testdata/comments-density-1.go b/testdata/comments_density_1.go
similarity index 100%
rename from testdata/comments-density-1.go
rename to testdata/comments_density_1.go
diff --git a/testdata/comments-density-2.go b/testdata/comments_density_2.go
similarity index 100%
rename from testdata/comments-density-2.go
rename to testdata/comments_density_2.go
diff --git a/testdata/comments-density-3.go b/testdata/comments_density_3.go
similarity index 100%
rename from testdata/comments-density-3.go
rename to testdata/comments_density_3.go
diff --git a/testdata/confusing-naming1.go b/testdata/confusing_naming1.go
similarity index 100%
rename from testdata/confusing-naming1.go
rename to testdata/confusing_naming1.go
diff --git a/testdata/confusing-naming2.go b/testdata/confusing_naming2.go
similarity index 100%
rename from testdata/confusing-naming2.go
rename to testdata/confusing_naming2.go
diff --git a/testdata/confusing-results.go b/testdata/confusing_results.go
similarity index 100%
rename from testdata/confusing-results.go
rename to testdata/confusing_results.go
diff --git a/testdata/constant-logical-expr.go b/testdata/constant_logical_expr.go
similarity index 100%
rename from testdata/constant-logical-expr.go
rename to testdata/constant_logical_expr.go
diff --git a/testdata/context-as-argument.go b/testdata/context_as_argument.go
similarity index 100%
rename from testdata/context-as-argument.go
rename to testdata/context_as_argument.go
diff --git a/testdata/cyclomatic-2.go b/testdata/cyclomatic_2.go
similarity index 100%
rename from testdata/cyclomatic-2.go
rename to testdata/cyclomatic_2.go
diff --git a/testdata/deep-exit.go b/testdata/deep_exit.go
similarity index 100%
rename from testdata/deep-exit.go
rename to testdata/deep_exit.go
diff --git a/testdata/deep-exit_test.go b/testdata/deep_exit_test.go
similarity index 100%
rename from testdata/deep-exit_test.go
rename to testdata/deep_exit_test.go
diff --git a/testdata/defer-loop-disabled.go b/testdata/defer_loop_disabled.go
similarity index 100%
rename from testdata/defer-loop-disabled.go
rename to testdata/defer_loop_disabled.go
diff --git a/testdata/defer-only-loop-enabled.go b/testdata/defer_only_loop_enabled.go
similarity index 100%
rename from testdata/defer-only-loop-enabled.go
rename to testdata/defer_only_loop_enabled.go
diff --git a/testdata/disable-annotations.go b/testdata/disable_annotations.go
similarity index 100%
rename from testdata/disable-annotations.go
rename to testdata/disable_annotations.go
diff --git a/testdata/disable-annotations2.go b/testdata/disable_annotations2.go
similarity index 100%
rename from testdata/disable-annotations2.go
rename to testdata/disable_annotations2.go
diff --git a/testdata/disable-annotations3.go b/testdata/disable_annotations3.go
similarity index 100%
rename from testdata/disable-annotations3.go
rename to testdata/disable_annotations3.go
diff --git a/testdata/duplicated-imports.go b/testdata/duplicated_imports.go
similarity index 100%
rename from testdata/duplicated-imports.go
rename to testdata/duplicated_imports.go
diff --git a/testdata/early-return.go b/testdata/early_return.go
similarity index 100%
rename from testdata/early-return.go
rename to testdata/early_return.go
diff --git a/testdata/early-return-scope.go b/testdata/early_return_scope.go
similarity index 100%
rename from testdata/early-return-scope.go
rename to testdata/early_return_scope.go
diff --git a/testdata/empty-block.go b/testdata/empty_block.go
similarity index 100%
rename from testdata/empty-block.go
rename to testdata/empty_block.go
diff --git a/testdata/empty-lines.go b/testdata/empty_lines.go
similarity index 100%
rename from testdata/empty-lines.go
rename to testdata/empty_lines.go
diff --git a/testdata/enforce-map-style-any.go b/testdata/enforce_map_style_any.go
similarity index 100%
rename from testdata/enforce-map-style-any.go
rename to testdata/enforce_map_style_any.go
diff --git a/testdata/enforce-map-style-literal.go b/testdata/enforce_map_style_literal.go
similarity index 100%
rename from testdata/enforce-map-style-literal.go
rename to testdata/enforce_map_style_literal.go
diff --git a/testdata/enforce-map-style-make.go b/testdata/enforce_map_style_make.go
similarity index 100%
rename from testdata/enforce-map-style-make.go
rename to testdata/enforce_map_style_make.go
diff --git a/testdata/enforce-repeated-arg-type-style-full-args.go b/testdata/enforce_repeated_arg_type_style_full_args.go
similarity index 100%
rename from testdata/enforce-repeated-arg-type-style-full-args.go
rename to testdata/enforce_repeated_arg_type_style_full_args.go
diff --git a/testdata/enforce-repeated-arg-type-style-full-return.go b/testdata/enforce_repeated_arg_type_style_full_return.go
similarity index 100%
rename from testdata/enforce-repeated-arg-type-style-full-return.go
rename to testdata/enforce_repeated_arg_type_style_full_return.go
diff --git a/testdata/enforce-repeated-arg-type-style-mixed-full-short.go b/testdata/enforce_repeated_arg_type_style_mixed_full_short.go
similarity index 100%
rename from testdata/enforce-repeated-arg-type-style-mixed-full-short.go
rename to testdata/enforce_repeated_arg_type_style_mixed_full_short.go
diff --git a/testdata/enforce-repeated-arg-type-style-mixed-short-full.go b/testdata/enforce_repeated_arg_type_style_mixed_short_full.go
similarity index 100%
rename from testdata/enforce-repeated-arg-type-style-mixed-short-full.go
rename to testdata/enforce_repeated_arg_type_style_mixed_short_full.go
diff --git a/testdata/enforce-repeated-arg-type-style-short-args.go b/testdata/enforce_repeated_arg_type_style_short_args.go
similarity index 100%
rename from testdata/enforce-repeated-arg-type-style-short-args.go
rename to testdata/enforce_repeated_arg_type_style_short_args.go
diff --git a/testdata/enforce-repeated-arg-type-style-short-return.go b/testdata/enforce_repeated_arg_type_style_short_return.go
similarity index 100%
rename from testdata/enforce-repeated-arg-type-style-short-return.go
rename to testdata/enforce_repeated_arg_type_style_short_return.go
diff --git a/testdata/enforce-slice-style-any.go b/testdata/enforce_slice_style_any.go
similarity index 100%
rename from testdata/enforce-slice-style-any.go
rename to testdata/enforce_slice_style_any.go
diff --git a/testdata/enforce-slice-style-literal.go b/testdata/enforce_slice_style_literal.go
similarity index 100%
rename from testdata/enforce-slice-style-literal.go
rename to testdata/enforce_slice_style_literal.go
diff --git a/testdata/enforce-slice-style-make.go b/testdata/enforce_slice_style_make.go
similarity index 100%
rename from testdata/enforce-slice-style-make.go
rename to testdata/enforce_slice_style_make.go
diff --git a/testdata/enforce-slice-style-nil.go b/testdata/enforce_slice_style_nil.go
similarity index 100%
rename from testdata/enforce-slice-style-nil.go
rename to testdata/enforce_slice_style_nil.go
diff --git a/testdata/error-strings-with-custom-functions.go b/testdata/error_strings_with_custom_functions.go
similarity index 100%
rename from testdata/error-strings-with-custom-functions.go
rename to testdata/error_strings_with_custom_functions.go
diff --git a/testdata/exported-issue-1002.go b/testdata/exported_issue_1002.go
similarity index 100%
rename from testdata/exported-issue-1002.go
rename to testdata/exported_issue_1002.go
diff --git a/testdata/exported-issue-1045.go b/testdata/exported_issue_1045.go
similarity index 100%
rename from testdata/exported-issue-1045.go
rename to testdata/exported_issue_1045.go
diff --git a/testdata/exported-issue-519.go b/testdata/exported_issue_519.go
similarity index 100%
rename from testdata/exported-issue-519.go
rename to testdata/exported_issue_519.go
diff --git a/testdata/exported-issue-552.go b/testdata/exported_issue_552.go
similarity index 100%
rename from testdata/exported-issue-552.go
rename to testdata/exported_issue_552.go
diff --git a/testdata/exported-issue-555.go b/testdata/exported_issue_555.go
similarity index 100%
rename from testdata/exported-issue-555.go
rename to testdata/exported_issue_555.go
diff --git a/testdata/file-length-limit-4-skip-comments-skip-blank.go b/testdata/file_length_limit_4_skip_comments_skip_blank.go
similarity index 100%
rename from testdata/file-length-limit-4-skip-comments-skip-blank.go
rename to testdata/file_length_limit_4_skip_comments_skip_blank.go
diff --git a/testdata/file-length-limit-6-skip-blank.go b/testdata/file_length_limit_6_skip_blank.go
similarity index 100%
rename from testdata/file-length-limit-6-skip-blank.go
rename to testdata/file_length_limit_6_skip_blank.go
diff --git a/testdata/file-length-limit-7-skip-comments.go b/testdata/file_length_limit_7_skip_comments.go
similarity index 100%
rename from testdata/file-length-limit-7-skip-comments.go
rename to testdata/file_length_limit_7_skip_comments.go
diff --git a/testdata/file-length-limit-9.go b/testdata/file_length_limit_9.go
similarity index 100%
rename from testdata/file-length-limit-9.go
rename to testdata/file_length_limit_9.go
diff --git a/testdata/file-length-limit-disabled.go b/testdata/file_length_limit_disabled.go
similarity index 100%
rename from testdata/file-length-limit-disabled.go
rename to testdata/file_length_limit_disabled.go
diff --git a/testdata/file-to-exclude.go b/testdata/file_to_exclude.go
similarity index 100%
rename from testdata/file-to-exclude.go
rename to testdata/file_to_exclude.go
diff --git a/testdata/filename-ok-default.go b/testdata/filename_ok_default.go
similarity index 100%
rename from testdata/filename-ok-default.go
rename to testdata/filename_ok_default.go
diff --git "a/testdata/filenam\320\265-with-non-ascii-char.go" "b/testdata/filenam\320\265_with_non_ascii_char.go"
similarity index 60%
rename from "testdata/filenam\320\265-with-non-ascii-char.go"
rename to "testdata/filenam\320\265_with_non_ascii_char.go"
index a4c665e..d6cf886 100644
--- "a/testdata/filenam\320\265-with-non-ascii-char.go"
+++ "b/testdata/filenam\320\265_with_non_ascii_char.go"
@@ -1,3 +1,3 @@
 package main
 
-// MATCH:1 /Filename filenamе-with-non-ascii-char.go is not of the format ^[_A-Za-z0-9][_A-Za-z0-9-]*.go$. Non ASCII character е (U+0435) found./
+// MATCH:1 /Filename filenamе_with_non_ascii_char.go is not of the format ^[_A-Za-z0-9][_A-Za-z0-9-]*.go$. Non ASCII character е (U+0435) found./
diff --git a/testdata/flag-param.go b/testdata/flag_param.go
similarity index 100%
rename from testdata/flag-param.go
rename to testdata/flag_param.go
diff --git a/testdata/function-length1.go b/testdata/function_length1.go
similarity index 100%
rename from testdata/function-length1.go
rename to testdata/function_length1.go
diff --git a/testdata/function-length2.go b/testdata/function_length2.go
similarity index 100%
rename from testdata/function-length2.go
rename to testdata/function_length2.go
diff --git a/testdata/function-length3.go b/testdata/function_length3.go
similarity index 100%
rename from testdata/function-length3.go
rename to testdata/function_length3.go
diff --git a/testdata/function-result-limit.go b/testdata/function_result_limit.go
similarity index 100%
rename from testdata/function-result-limit.go
rename to testdata/function_result_limit.go
diff --git a/testdata/get-return.go b/testdata/get_return.go
similarity index 100%
rename from testdata/get-return.go
rename to testdata/get_return.go
diff --git a/testdata/go1.21/redefines-builtin-id.go b/testdata/go1.21/redefines_builtin_id.go
similarity index 100%
rename from testdata/go1.21/redefines-builtin-id.go
rename to testdata/go1.21/redefines_builtin_id.go
diff --git a/testdata/go1.22/range-val-address.go b/testdata/go1.22/range_val_address.go
similarity index 100%
rename from testdata/go1.22/range-val-address.go
rename to testdata/go1.22/range_val_address.go
diff --git a/testdata/go1.22/range-val-in-closure.go b/testdata/go1.22/range_val_in_closure.go
similarity index 100%
rename from testdata/go1.22/range-val-in-closure.go
rename to testdata/go1.22/range_val_in_closure.go
diff --git a/testdata/goUnknown/go.mod b/testdata/goUnknown/go.mod
new file mode 100644
index 0000000..33e314b
--- /dev/null
+++ b/testdata/goUnknown/go.mod
@@ -0,0 +1,2 @@
+module github.com/mgechev/revive/testdata
+
diff --git a/testdata/goUnknown/issue1100.go b/testdata/goUnknown/issue1100.go
new file mode 100644
index 0000000..527b33c
--- /dev/null
+++ b/testdata/goUnknown/issue1100.go
@@ -0,0 +1,104 @@
+package fixtures
+
+import (
+	"context"
+	"fmt"
+	"os"
+)
+
+type testLogger struct{}
+
+func (l *testLogger) Info(ctx context.Context, msg string) {}
+
+func getLogger() *testLogger {
+	return &testLogger{}
+}
+
+func test1007() {
+	getLogger().Info(context.Background(), "test1007")
+	getLogger().Info(context.Background(), "test1007")
+	getLogger().Info(context.Background(), "test1007")
+}
+
+func foo(a float32, b string, c any, d int) {
+	a = 1.0 // ignore
+	b = "ignore"
+	c = 2              // ignore
+	println("lit", 12) // MATCH /avoid magic numbers like '12', create a named constant for it/
+	if a == 12.50 {    // MATCH /avoid magic numbers like '12.50', create a named constant for it/
+		if b == "lit" {
+			c = "lit" // MATCH /string literal "lit" appears, at least, 3 times, create a named constant for it/
+		}
+		for i := 0; i < 1; i++ {
+			println("lit")
+		}
+	}
+
+	println(0666)           // MATCH /avoid magic numbers like '0666', create a named constant for it/
+	os.Chmod("test", 0666)  // ignore
+	os.FindProcess(102100)  // ignore
+	fmt.Println("test", 12) // ignore
+	fmt.Printf("%d", 100)   // MATCH /avoid magic numbers like '100', create a named constant for it/
+	myPrintln("%d", 100)    // MATCH /avoid magic numbers like '100', create a named constant for it/
+	ignoredFunc(1000)       // ignore
+	ignoredFunc1(1000)      // ignore - match regexp too
+
+	println("The result of calling myFunc is: ", ignoredFunc(100))             // ignore
+	println("result is: ", ignoredFunc(notIgnoredFunc(ignoredFunc(100))))      // ignore
+	println("result of calling myFunc is: ", notIgnoredFunc(ignoredFunc(100))) // ignore
+
+	println("result myFunc is: ", notIgnoredFunc(100))           // MATCH /avoid magic numbers like '100', create a named constant for it/
+	println("The result is: ", ignoredFunc(notIgnoredFunc(100))) // MATCH /avoid magic numbers like '100', create a named constant for it/
+}
+
+func myPrintln(s string, num int) {
+
+}
+
+func ignoredFunc1(num int) int {
+	return num
+}
+
+func ignoredFunc(num int) int {
+	return num
+}
+
+func notIgnoredFunc(num int) int {
+	return num
+}
+
+func tagsInStructLiteralsShouldBeOK() {
+	a := struct {
+		X int `json:"x"`
+	}{}
+
+	b := struct {
+		X int `json:"x"`
+	}{}
+
+	c := struct {
+		X int `json:"x"`
+	}{}
+
+	d := struct {
+		X int `json:"x"`
+		Y int `json:"y"`
+	}{}
+
+	e := struct {
+		X int `json:"x"`
+		Y int `json:"y"`
+	}{}
+
+	var f struct {
+		X int `json:"x"`
+		Y int `json:"y"`
+	}
+
+	var g struct {
+		X int `json:"x"`
+		Y int `json:"y"`
+	}
+
+	_, _, _, _, _, _, _ = a, b, c, d, e, f, g
+}