From 7dcb7970003ab3676deb66a7223bd6f094205e85 Mon Sep 17 00:00:00 2001 From: Andrey Kuleshov Date: Fri, 10 Jun 2022 21:32:25 +0300 Subject: [PATCH 1/6] ### What's done: - removed "old" binaries --- buildSrc/src/main/kotlin/Versions.kt | 8 +- examples/kotlin-diktat/save.toml | 4 +- .../chapter1/EnumValueSnakeCaseTest.kt | 20 +- .../warn-dir/chapter1/GenericFunctionTest.kt | 14 +- .../warn-dir/chapter1/SmallTest.kt | 6 +- .../warn-dir/chapter2/GenericFunctionTest.kt | 14 +- .../warn-dir/chapter3/GenericFunctionTest.kt | 14 +- .../warn-dir/chapter4/GenericFunctionTest.kt | 6 +- examples/kotlin-diktat/warn-dir/save.toml | 2 +- .../warn/chapter1/EnumValueSnakeCaseTest.kt | 1774 ++++++++++++++++- gradle.properties | 2 + save-cli/build.gradle.kts | 1 - .../com/saveourtool/save/cli/GeneralTest.kt | 4 +- .../save/core/utils/ProcessBuilder.kt | 5 +- save-core/build.gradle.kts | 20 - .../save/core/test/utils/TestUtilsCommon.kt | 2 +- 16 files changed, 1822 insertions(+), 74 deletions(-) diff --git a/buildSrc/src/main/kotlin/Versions.kt b/buildSrc/src/main/kotlin/Versions.kt index cabae09d3..4e8b06928 100644 --- a/buildSrc/src/main/kotlin/Versions.kt +++ b/buildSrc/src/main/kotlin/Versions.kt @@ -2,13 +2,9 @@ object Versions { object IntegrationTest { - const val ktlint = "0.43.2" + const val ktlint = "0.45.2" const val ktlintLink = "https://github.com/pinterest/ktlint/releases/download/$ktlint/ktlint" - const val diktat = "1.0.2" + const val diktat = "1.1.0" const val diktatLink = "https://github.com/saveourtool/diKTat/releases/download/v$diktat/diktat-$diktat.jar" - const val oldKtlint = "0.39.0" - const val oldKtlintLink = "https://github.com/pinterest/ktlint/releases/download/$oldKtlint/ktlint" - const val oldDiktat = "1.0.0-rc.2" - const val oldDiktatLink = "https://github.com/saveourtool/diKTat/releases/download/v$oldDiktat/diktat-$oldDiktat.jar" } } diff --git a/examples/kotlin-diktat/save.toml b/examples/kotlin-diktat/save.toml index 1be4e070d..344d7e543 100644 --- a/examples/kotlin-diktat/save.toml +++ b/examples/kotlin-diktat/save.toml @@ -1,6 +1,6 @@ [general] - execCmd = "java -jar ktlint-old --disabled_rules=standard -R diktat-old.jar" - description = "Test for diktat - linter and formatter for Kotlin" + execCmd = "java -jar ktlint --disabled_rules=standard -R diktat.jar" + description = "22 test for diktat (linter and formatter for Kotlin)" language = "Kotlin" # this is the default value, you don't need to add it explicitly, but can be useful, if you have different pattern: expectedWarningsPattern = "// ;warn:?(.*):(\\d*): (.+)" diff --git a/examples/kotlin-diktat/warn-dir/chapter1/EnumValueSnakeCaseTest.kt b/examples/kotlin-diktat/warn-dir/chapter1/EnumValueSnakeCaseTest.kt index 720e05663..6d4568aaa 100644 --- a/examples/kotlin-diktat/warn-dir/chapter1/EnumValueSnakeCaseTest.kt +++ b/examples/kotlin-diktat/warn-dir/chapter1/EnumValueSnakeCaseTest.kt @@ -1,19 +1,19 @@ -// ;warn:2:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save +// ;warn:2:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} package com.saveourtool.diktat.test.resources.test.paragraph1.naming.enum_ -// ;warn:4:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) -// ;warn:8:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect -// ;warn:17:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon -// ;warn:17:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma +// ;warn:4:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} +// ;warn:8:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:17:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} +// ;warn:17:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} enum class EnumValueSnakeCaseTest { - // ;warn:10:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + // ;warn:10:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} paSC_SAl_l, - // ;warn:12:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: PascAsl_f + // ;warn:12:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: PascAsl_f{{.*}} PascAsl_f, - // ;warn:14:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: START_PSaaa_DFE + // ;warn:14:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: START_PSaaa_DFE{{.*}} START_PSaaa_DFE, - // ;warn:16:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: _NAme_MYa_sayR + // ;warn:16:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: _NAme_MYa_sayR{{.*}} _NAme_MYa_sayR, - // ;warn:18:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: NAme_MYa_sayR_ + // ;warn:18:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: NAme_MYa_sayR_{{.*}} NAme_MYa_sayR_ } diff --git a/examples/kotlin-diktat/warn-dir/chapter1/GenericFunctionTest.kt b/examples/kotlin-diktat/warn-dir/chapter1/GenericFunctionTest.kt index 5420aa628..22bb156b5 100644 --- a/examples/kotlin-diktat/warn-dir/chapter1/GenericFunctionTest.kt +++ b/examples/kotlin-diktat/warn-dir/chapter1/GenericFunctionTest.kt @@ -1,15 +1,15 @@ -// ;warn:3:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save -// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName +// ;warn:3:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} +// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName{{.*}} package com.saveourtool.diktat.test.paragraph1.naming.generic private class ClassName { private fun lock(body: ((Template?) -> T?)?, value: Template?): T? { try { - // ;warn:10:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected) - // ;warn:10:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:10:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected){{.*}} + // ;warn:10:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableName: Template? = null - // ;warn:13:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT - // ;warn:13:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:13:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT{{.*}} + // ;warn:13:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableT: T? = null println(variableT) return body!!(variableName) @@ -18,7 +18,7 @@ private class ClassName { } } - // ;warn:21:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo + // ;warn:21:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo{{.*}} fun foo(var1: T, var2: ((T?) -> T?)?) { lock(var2, var1) } diff --git a/examples/kotlin-diktat/warn-dir/chapter1/SmallTest.kt b/examples/kotlin-diktat/warn-dir/chapter1/SmallTest.kt index b91c2da6c..44c8721ac 100644 --- a/examples/kotlin-diktat/warn-dir/chapter1/SmallTest.kt +++ b/examples/kotlin-diktat/warn-dir/chapter1/SmallTest.kt @@ -1,4 +1,4 @@ -// ;warn:1:1: [FILE_CONTAINS_ONLY_COMMENTS] empty files or files that contain only comments should be avoided: file contains no code (cannot be auto-corrected) -// ;warn:1:1: [HEADER_MISSING_IN_NON_SINGLE_CLASS_FILE] files that contain multiple or no classes should contain description of what is inside of this file: there are 0 declared classes and/or objects (cannot be auto-corrected) -// ;warn:4:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save +// ;warn:1:1: [FILE_CONTAINS_ONLY_COMMENTS] empty files or files that contain only comments should be avoided: file contains no code (cannot be auto-corrected){{.*}} +// ;warn:1:1: [HEADER_MISSING_IN_NON_SINGLE_CLASS_FILE] files that contain multiple or no classes should contain description of what is inside of this file: there are 0 declared classes and/or objects (cannot be auto-corrected){{.*}} +// ;warn:4:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} package com.saveourtool.diktat.test.paragraph1.naming.generic diff --git a/examples/kotlin-diktat/warn-dir/chapter2/GenericFunctionTest.kt b/examples/kotlin-diktat/warn-dir/chapter2/GenericFunctionTest.kt index c1cf3373e..f6f72820e 100644 --- a/examples/kotlin-diktat/warn-dir/chapter2/GenericFunctionTest.kt +++ b/examples/kotlin-diktat/warn-dir/chapter2/GenericFunctionTest.kt @@ -1,15 +1,15 @@ -// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName -// ;warn:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save +// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName{{.*}} +// ;warn:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} package com.saveourtool.diktat.test.paragraph1.naming.generic private class ClassName { private fun lock(body: ((Template?) -> T?)?, value: Template?): T? { try { - // ;warn:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected) - // ;warn:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected){{.*}} + // ;warn:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableName: Template? = null - // ;warn:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT - // ;warn:$line+1:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT{{.*}} + // ;warn:$line+1:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableT: T? = null println(variableT) return body!!(variableName) @@ -18,7 +18,7 @@ private class ClassName { } } - // ;warn:21:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo + // ;warn:21:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo{{.*}} fun foo(var1: T, var2: ((T?) -> T?)?) { lock(var2, var1) } diff --git a/examples/kotlin-diktat/warn-dir/chapter3/GenericFunctionTest.kt b/examples/kotlin-diktat/warn-dir/chapter3/GenericFunctionTest.kt index 0311bcc2c..db16a93ad 100644 --- a/examples/kotlin-diktat/warn-dir/chapter3/GenericFunctionTest.kt +++ b/examples/kotlin-diktat/warn-dir/chapter3/GenericFunctionTest.kt @@ -1,15 +1,15 @@ -// ;warn:$line:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName -// ;warn:$line+1:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save +// ;warn:$line:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName{{.*}} +// ;warn:$line+1:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} package com.saveourtool.diktat.test.paragraph1.naming.generic private class ClassName { private fun lock(body: ((Template?) -> T?)?, value: Template?): T? { try { - // ;warn:$line+2:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected) - // ;warn:$line+1:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:$line+2:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected){{.*}} + // ;warn:$line+1:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableName: Template? = null - // ;warn:$line+2:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT - // ;warn:$line+1:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:$line+2:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT{{.*}} + // ;warn:$line+1:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableT: T? = null println(variableT) return body!!(variableName) @@ -19,7 +19,7 @@ private class ClassName { } // comment comment comment - // ;warn:$line-1:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo + // ;warn:$line-1:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo{{.*}} fun foo(var1: T, var2: ((T?) -> T?)?) { lock(var2, var1) } diff --git a/examples/kotlin-diktat/warn-dir/chapter4/GenericFunctionTest.kt b/examples/kotlin-diktat/warn-dir/chapter4/GenericFunctionTest.kt index 6948a461e..6720ace5c 100644 --- a/examples/kotlin-diktat/warn-dir/chapter4/GenericFunctionTest.kt +++ b/examples/kotlin-diktat/warn-dir/chapter4/GenericFunctionTest.kt @@ -1,4 +1,4 @@ -/* ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName */ +/* ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName{{.*}} */ package com.saveourtool.save.test.paragraph1.naming.generic private class ClassName { @@ -7,7 +7,7 @@ private class ClassName { val variableName: Template /* ;warn:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should * be in lowerCamelCase and should contain only latin (ASCII) - * letters or numbers and should start from lower letter: variableT + * letters or numbers and should start from lower letter: variableT{{.*}} * */ val variableT: T println(variableT) @@ -18,7 +18,7 @@ private class ClassName { } /* ;warn:20:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected - * functions should have Kdoc with proper tags: foo */ + * functions should have Kdoc with proper tags: foo{{.*}} */ fun foo(var1: T, var2: ((T?) -> T?)?) { lock(var2, var1) } diff --git a/examples/kotlin-diktat/warn-dir/save.toml b/examples/kotlin-diktat/warn-dir/save.toml index 4c92e7593..56c7352f8 100644 --- a/examples/kotlin-diktat/warn-dir/save.toml +++ b/examples/kotlin-diktat/warn-dir/save.toml @@ -1,5 +1,5 @@ [general] - execCmd = "java -jar ktlint-old --disabled_rules=standard -R diktat-old.jar" + execCmd = "java -jar ktlint --disabled_rules=standard -R diktat.jar" tags = ["warn"] description = "Test for directory mode" diff --git a/examples/kotlin-diktat/warn/chapter1/EnumValueSnakeCaseTest.kt b/examples/kotlin-diktat/warn/chapter1/EnumValueSnakeCaseTest.kt index 6aa3ef00b..fc11d10d4 100644 --- a/examples/kotlin-diktat/warn/chapter1/EnumValueSnakeCaseTest.kt +++ b/examples/kotlin-diktat/warn/chapter1/EnumValueSnakeCaseTest.kt @@ -1,4 +1,1760 @@ -package com.saveourtool.diktat.test.resources.test.paragraph1.naming.enum_ +@file:Suppress("PACKAGE_NAME_INCORRECT_PREFIX") + +package com.saveourtool.save.test.resources.test.paragraph1.naming.enum_ + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// =============================================================== // + + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} // ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) // ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect @@ -11,5 +1767,19 @@ enum class EnumValueSnakeCaseTest { PascAsl_f // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma - // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} } + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} \ No newline at end of file diff --git a/gradle.properties b/gradle.properties index edf424555..39f484e28 100644 --- a/gradle.properties +++ b/gradle.properties @@ -14,3 +14,5 @@ kotlin.native.cacheKind.linuxX64=none kotlin.mpp.hierarchicalStructureSupport=true # making custom cinterop libraries available in shared source sets kotlin.mpp.enableCInteropCommonization=true +gprUser=akuleshov7 +gprKey=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 \ No newline at end of file diff --git a/save-cli/build.gradle.kts b/save-cli/build.gradle.kts index 92429d54c..f6530466c 100644 --- a/save-cli/build.gradle.kts +++ b/save-cli/build.gradle.kts @@ -84,7 +84,6 @@ kotlin { tasks.withType().configureEach { dependsOn(":save-core:downloadTestResources") - dependsOn(":save-core:downloadOldTestResources") } // disable building of some binaries to speed up build diff --git a/save-cli/src/jvmTest/kotlin/com/saveourtool/save/cli/GeneralTest.kt b/save-cli/src/jvmTest/kotlin/com/saveourtool/save/cli/GeneralTest.kt index 5b033fa0d..0993adf6d 100644 --- a/save-cli/src/jvmTest/kotlin/com/saveourtool/save/cli/GeneralTest.kt +++ b/save-cli/src/jvmTest/kotlin/com/saveourtool/save/cli/GeneralTest.kt @@ -62,8 +62,8 @@ class GeneralTest { assertTrue(fs.exists(destination)) // Check for existence of diktat and ktlint - assertTrue(fs.exists((examplesDir.toPath() / "diktat-old.jar"))) - assertTrue(fs.exists((examplesDir.toPath() / "ktlint-old"))) + assertTrue(fs.exists((examplesDir.toPath() / "diktat.jar"))) + assertTrue(fs.exists((examplesDir.toPath() / "ktlint"))) // Make sure, that we will check report, which will be obtained after current execution; remove old report if exist val reportFile = examplesDir.toPath() / "save.out.json".toPath() diff --git a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt index 48ec3bc3e..8f717c5c6 100644 --- a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt +++ b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt @@ -87,8 +87,7 @@ class ProcessBuilder(private val useInternalRedirections: Boolean, private val f } // Temporary directory for stderr and stdout (posix `system()` can't separate streams, so we do it ourselves) - val tmpDir = (FileSystem.SYSTEM_TEMPORARY_DIRECTORY / - ("ProcessBuilder_" + Clock.System.now().toEpochMilliseconds()).toPath()) + val tmpDir = "D:/".toPath() logTrace("Creating temp directory: $tmpDir") // Path to stdout file val stdoutFile = tmpDir / "stdout.txt" @@ -116,6 +115,8 @@ class ProcessBuilder(private val useInternalRedirections: Boolean, private val f logErrorAndThrowProcessBuilderException(ex.message ?: "Couldn't execute $cmd") } val stdout = fs.readLines(stdoutFile) + + println("HERE $stdout") val stderr = fs.readLines(stderrFile) fs.myDeleteRecursively(tmpDir) logTrace("Removed temp directory $tmpDir") diff --git a/save-core/build.gradle.kts b/save-core/build.gradle.kts index d81067ec0..b04a11910 100644 --- a/save-core/build.gradle.kts +++ b/save-core/build.gradle.kts @@ -71,23 +71,6 @@ tasks.withType>().forEach { it.dependsOn(generateVersionFileTaskProvider) } -tasks.register("downloadOldTestResources") { - src(listOf( - Versions.IntegrationTest.oldKtlintLink, - Versions.IntegrationTest.oldDiktatLink, - )) - dest("../examples/kotlin-diktat") - doLast { - file("../examples/kotlin-diktat/diktat-${Versions.IntegrationTest.oldDiktat}.jar").renameTo( - file("../examples/kotlin-diktat/diktat-old.jar") - ) - - file("../examples/kotlin-diktat/ktlint").renameTo( - file("../examples/kotlin-diktat/ktlint-old") - ) - } -} - tasks.register("downloadTestResources") { src(listOf( Versions.IntegrationTest.ktlintLink, @@ -105,14 +88,11 @@ val cleanupTask = tasks.register("cleanupTestResources") { this.dependsOn(":save-cli:jvmTest") mustRunAfter(tasks.withType()) doFirst { - file("../examples/kotlin-diktat/ktlint-old").delete() file("../examples/kotlin-diktat/ktlint").delete() - file("../examples/kotlin-diktat/diktat-old.jar").delete() file("../examples/kotlin-diktat/diktat.jar").delete() } } tasks.withType().configureEach { dependsOn("downloadTestResources") - dependsOn("downloadOldTestResources") finalizedBy("cleanupTestResources") } diff --git a/save-core/src/commonNonJsTest/kotlin/com/saveourtool/save/core/test/utils/TestUtilsCommon.kt b/save-core/src/commonNonJsTest/kotlin/com/saveourtool/save/core/test/utils/TestUtilsCommon.kt index 498f83267..40b59ffda 100644 --- a/save-core/src/commonNonJsTest/kotlin/com/saveourtool/save/core/test/utils/TestUtilsCommon.kt +++ b/save-core/src/commonNonJsTest/kotlin/com/saveourtool/save/core/test/utils/TestUtilsCommon.kt @@ -50,7 +50,7 @@ fun runTestsWithDiktat( mutableTestDir.add(0, "../examples/kotlin-diktat/") val saveProperties = SaveProperties( - logType = LogType.ALL, + logType = LogType.DEBUG, testFiles = mutableTestDir, reportType = ReportType.TEST, resultOutput = OutputStreamType.STDOUT, From 43d1aa5add538517643ea68916103fcd5a25d26f Mon Sep 17 00:00:00 2001 From: Andrey Kuleshov Date: Fri, 10 Jun 2022 21:32:25 +0300 Subject: [PATCH 2/6] ### What's done: - removed "old" binaries --- buildSrc/src/main/kotlin/Versions.kt | 8 +- .../saveourtool/save/chapter1/Bug1Expected.kt | 14 +- .../saveourtool/save/chapter2/Bug2Expected.kt | 8 +- .../save/chapter3/Example1Expected.kt | 8 +- .../src/kotlin/EnumValueSnakeCaseTest.kt | 12 +- .../src/kotlin/EnumValueSnakeCaseTest.kt | 12 +- examples/kotlin-diktat/save.toml | 4 +- .../chapter1/EnumValueSnakeCaseTest.kt | 20 +-- .../warn-dir/chapter1/GenericFunctionTest.kt | 14 +- .../warn-dir/chapter1/SmallTest.kt | 6 +- .../warn-dir/chapter2/GenericFunctionTest.kt | 14 +- .../warn-dir/chapter3/GenericFunctionTest.kt | 14 +- .../warn-dir/chapter4/GenericFunctionTest.kt | 6 +- examples/kotlin-diktat/warn-dir/save.toml | 2 +- .../warn/chapter1/EnumValueSnakeCaseTest.kt | 120 ++++++++++++++++-- .../warn/chapter1/GenericFunctionTest.kt | 14 +- .../IgnoreLinesTest/EnumTestDetection.kt | 14 +- .../EnumValueSnakeCaseTest.kt | 2 +- .../TestResultsFileTest/EnumTestDetection.kt | 12 +- .../TestsWithRegex/EnumTestDetection.kt | 12 +- .../NoMatchingTests/EnumTestDetection.kt | 12 +- .../NoMatchingTests/GenericFunctionTest.kt | 14 +- .../warn/chapter1/ThisShouldAlwaysFailTest.kt | 4 +- .../warn/chapter2/EnumValueSnakeCaseTest.kt | 12 +- .../warn/chapter2/GenericFunctionTest.kt | 14 +- gradle.properties | 3 + save-cli/build.gradle.kts | 1 - .../com/saveourtool/save/cli/GeneralTest.kt | 5 +- .../save/core/utils/ProcessBuilder.kt | 3 + save-core/build.gradle.kts | 20 --- .../save/core/test/utils/TestUtilsCommon.kt | 9 +- .../save/plugin/warn/utils/StringUtils.kt | 33 +++-- .../save/plugin/warn/utils/StringUtilsTest.kt | 13 ++ 33 files changed, 283 insertions(+), 176 deletions(-) diff --git a/buildSrc/src/main/kotlin/Versions.kt b/buildSrc/src/main/kotlin/Versions.kt index cabae09d3..4e8b06928 100644 --- a/buildSrc/src/main/kotlin/Versions.kt +++ b/buildSrc/src/main/kotlin/Versions.kt @@ -2,13 +2,9 @@ object Versions { object IntegrationTest { - const val ktlint = "0.43.2" + const val ktlint = "0.45.2" const val ktlintLink = "https://github.com/pinterest/ktlint/releases/download/$ktlint/ktlint" - const val diktat = "1.0.2" + const val diktat = "1.1.0" const val diktatLink = "https://github.com/saveourtool/diKTat/releases/download/v$diktat/diktat-$diktat.jar" - const val oldKtlint = "0.39.0" - const val oldKtlintLink = "https://github.com/pinterest/ktlint/releases/download/$oldKtlint/ktlint" - const val oldDiktat = "1.0.0-rc.2" - const val oldDiktatLink = "https://github.com/saveourtool/diKTat/releases/download/v$oldDiktat/diktat-$oldDiktat.jar" } } diff --git a/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter1/Bug1Expected.kt b/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter1/Bug1Expected.kt index 4b6f900f8..73ccf62b4 100644 --- a/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter1/Bug1Expected.kt +++ b/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter1/Bug1Expected.kt @@ -1,19 +1,19 @@ -// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: Bug1Expected.kt vs D +// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: Bug1Expected.kt vs D{{.*}} package com.saveourtool.save.chapter1 -// ;warn:4:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: D (cannot be auto-corrected) -// ;warn:7:7: [CLASS_NAME_INCORRECT] class/enum/interface name should be in PascalCase and should contain only latin (ASCII) letters or numbers: D -// ;warn:7:7: [IDENTIFIER_LENGTH] identifier's length is incorrect, it should be in range of [2, 64] symbols: D (cannot be auto-corrected) +// ;warn:4:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: D (cannot be auto-corrected){{.*}} +// ;warn:7:7: [CLASS_NAME_INCORRECT] class/enum/interface name should be in PascalCase and should contain only latin (ASCII) letters or numbers: D{{.*}} +// ;warn:7:7: [IDENTIFIER_LENGTH] identifier's length is incorrect, it should be in range of [2, 64] symbols: D (cannot be auto-corrected){{.*}} class D { - // ;warn:8:5: [MISSING_KDOC_CLASS_ELEMENTS] all public, internal and protected classes, functions and variables inside the class should have Kdoc: x (cannot be auto-corrected) + // ;warn:8:5: [MISSING_KDOC_CLASS_ELEMENTS] all public, internal and protected classes, functions and variables inside the class should have Kdoc: x (cannot be auto-corrected){{.*}} val x = 0 - // ;warn:13:8: [KDOC_NO_EMPTY_TAGS] no empty descriptions in tag blocks are allowed: @return (cannot be auto-corrected) + // ;warn:13:8: [KDOC_NO_EMPTY_TAGS] no empty descriptions in tag blocks are allowed: @return (cannot be auto-corrected){{.*}} /** * @return */ fun bar(): Bar { - // ;warn:17:19: [MAGIC_NUMBER] avoid using magic numbers, instead define constants with clear names describing what the magic number means: 42 (cannot be auto-corrected) + // ;warn:17:19: [MAGIC_NUMBER] avoid using magic numbers, instead define constants with clear names describing what the magic number means: 42 (cannot be auto-corrected){{.*}} val qux = 42 return Bar(qux) } diff --git a/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter2/Bug2Expected.kt b/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter2/Bug2Expected.kt index d8cb7d047..34b388226 100644 --- a/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter2/Bug2Expected.kt +++ b/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter2/Bug2Expected.kt @@ -1,4 +1,4 @@ -// ;warn:1:1: [HEADER_MISSING_IN_NON_SINGLE_CLASS_FILE] files that contain multiple or no classes should contain description of what is inside of this file: there are 2 declared classes and/or objects (cannot be auto-corrected) +// ;warn:1:1: [HEADER_MISSING_IN_NON_SINGLE_CLASS_FILE] files that contain multiple or no classes should contain description of what is inside of this file: there are 2 declared classes and/or objects (cannot be auto-corrected){{.*}} package com.saveourtool.save.chapter2 import org.slf4j.LoggerFactory @@ -26,7 +26,7 @@ internal fun createWithFile( containerName: String, file: File, resources: Collection = emptySet() - // ;warn:30:3: [EMPTY_BLOCK_STRUCTURE_ERROR] incorrect format of empty block: empty blocks are forbidden unless it is function with override keyword (cannot be auto-corrected) + // ;warn:30:3: [EMPTY_BLOCK_STRUCTURE_ERROR] incorrect format of empty block: empty blocks are forbidden unless it is function with override keyword (cannot be auto-corrected){{.*}} ) {} private fun foo(node: ASTNode) { @@ -37,10 +37,10 @@ private fun foo(node: ASTNode) { } } val qwe = a && - // ;warn:41:1: [WRONG_INDENTATION] only spaces are allowed for indentation and each indentation should equal to 4 spaces (tabs are not allowed): expected 12 but was 8 + // ;warn:41:1: [WRONG_INDENTATION] only spaces are allowed for indentation and each indentation should equal to 4 spaces (tabs are not allowed): expected 12 but was 8{{.*}} b val qwe = a && - // ;warn:44:1: [WRONG_INDENTATION] only spaces are allowed for indentation and each indentation should equal to 4 spaces (tabs are not allowed): expected 12 but was 8 + // ;warn:44:1: [WRONG_INDENTATION] only spaces are allowed for indentation and each indentation should equal to 4 spaces (tabs are not allowed): expected 12 but was 8{{.*}} b // comment diff --git a/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter3/Example1Expected.kt b/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter3/Example1Expected.kt index ba6bb2a41..94e1ec767 100644 --- a/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter3/Example1Expected.kt +++ b/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter3/Example1Expected.kt @@ -1,10 +1,10 @@ -// ;warn:1:1 [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: Example1Expected.kt vs Example +// ;warn:1:1 [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: Example1Expected.kt vs Example{{.*}} package com.saveourtool.save.chapter3 -// ;warn:4:1 [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: Example (cannot be auto-corrected) -// ;warn:4:1 [USE_DATA_CLASS] this class can be converted to a data class: Example (cannot be auto-corrected) +// ;warn:4:1 [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: Example (cannot be auto-corrected){{.*}} +// ;warn:4:1 [USE_DATA_CLASS] this class can be converted to a data class: Example (cannot be auto-corrected){{.*}} class Example { - // ;warn:7:5 [MISSING_KDOC_CLASS_ELEMENTS] all public, internal and protected classes, functions and variables inside the class should have Kdoc: isValid (cannot be auto-corrected) + // ;warn:7:5 [MISSING_KDOC_CLASS_ELEMENTS] all public, internal and protected classes, functions and variables inside the class should have Kdoc: isValid (cannot be auto-corrected){{.*}} @get:JvmName("getIsValid") val isValid = true } diff --git a/examples/kotlin-diktat/sarif-actual/src/kotlin/EnumValueSnakeCaseTest.kt b/examples/kotlin-diktat/sarif-actual/src/kotlin/EnumValueSnakeCaseTest.kt index 6aa3ef00b..1ac0c3747 100644 --- a/examples/kotlin-diktat/sarif-actual/src/kotlin/EnumValueSnakeCaseTest.kt +++ b/examples/kotlin-diktat/sarif-actual/src/kotlin/EnumValueSnakeCaseTest.kt @@ -1,15 +1,15 @@ package com.saveourtool.diktat.test.resources.test.paragraph1.naming.enum_ -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) -// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +// x§and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} enum class EnumValueSnakeCaseTest { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} paSC_SAl_l, - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} } diff --git a/examples/kotlin-diktat/sarif-expected/src/kotlin/EnumValueSnakeCaseTest.kt b/examples/kotlin-diktat/sarif-expected/src/kotlin/EnumValueSnakeCaseTest.kt index 6aa3ef00b..7f554e1b9 100644 --- a/examples/kotlin-diktat/sarif-expected/src/kotlin/EnumValueSnakeCaseTest.kt +++ b/examples/kotlin-diktat/sarif-expected/src/kotlin/EnumValueSnakeCaseTest.kt @@ -1,15 +1,15 @@ package com.saveourtool.diktat.test.resources.test.paragraph1.naming.enum_ -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) -// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} enum class EnumValueSnakeCaseTest { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} paSC_SAl_l, - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} } diff --git a/examples/kotlin-diktat/save.toml b/examples/kotlin-diktat/save.toml index 1be4e070d..344d7e543 100644 --- a/examples/kotlin-diktat/save.toml +++ b/examples/kotlin-diktat/save.toml @@ -1,6 +1,6 @@ [general] - execCmd = "java -jar ktlint-old --disabled_rules=standard -R diktat-old.jar" - description = "Test for diktat - linter and formatter for Kotlin" + execCmd = "java -jar ktlint --disabled_rules=standard -R diktat.jar" + description = "22 test for diktat (linter and formatter for Kotlin)" language = "Kotlin" # this is the default value, you don't need to add it explicitly, but can be useful, if you have different pattern: expectedWarningsPattern = "// ;warn:?(.*):(\\d*): (.+)" diff --git a/examples/kotlin-diktat/warn-dir/chapter1/EnumValueSnakeCaseTest.kt b/examples/kotlin-diktat/warn-dir/chapter1/EnumValueSnakeCaseTest.kt index 720e05663..6d4568aaa 100644 --- a/examples/kotlin-diktat/warn-dir/chapter1/EnumValueSnakeCaseTest.kt +++ b/examples/kotlin-diktat/warn-dir/chapter1/EnumValueSnakeCaseTest.kt @@ -1,19 +1,19 @@ -// ;warn:2:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save +// ;warn:2:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} package com.saveourtool.diktat.test.resources.test.paragraph1.naming.enum_ -// ;warn:4:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) -// ;warn:8:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect -// ;warn:17:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon -// ;warn:17:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma +// ;warn:4:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} +// ;warn:8:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:17:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} +// ;warn:17:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} enum class EnumValueSnakeCaseTest { - // ;warn:10:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + // ;warn:10:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} paSC_SAl_l, - // ;warn:12:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: PascAsl_f + // ;warn:12:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: PascAsl_f{{.*}} PascAsl_f, - // ;warn:14:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: START_PSaaa_DFE + // ;warn:14:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: START_PSaaa_DFE{{.*}} START_PSaaa_DFE, - // ;warn:16:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: _NAme_MYa_sayR + // ;warn:16:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: _NAme_MYa_sayR{{.*}} _NAme_MYa_sayR, - // ;warn:18:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: NAme_MYa_sayR_ + // ;warn:18:5: [ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: NAme_MYa_sayR_{{.*}} NAme_MYa_sayR_ } diff --git a/examples/kotlin-diktat/warn-dir/chapter1/GenericFunctionTest.kt b/examples/kotlin-diktat/warn-dir/chapter1/GenericFunctionTest.kt index 5420aa628..22bb156b5 100644 --- a/examples/kotlin-diktat/warn-dir/chapter1/GenericFunctionTest.kt +++ b/examples/kotlin-diktat/warn-dir/chapter1/GenericFunctionTest.kt @@ -1,15 +1,15 @@ -// ;warn:3:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save -// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName +// ;warn:3:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} +// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName{{.*}} package com.saveourtool.diktat.test.paragraph1.naming.generic private class ClassName { private fun lock(body: ((Template?) -> T?)?, value: Template?): T? { try { - // ;warn:10:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected) - // ;warn:10:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:10:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected){{.*}} + // ;warn:10:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableName: Template? = null - // ;warn:13:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT - // ;warn:13:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:13:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT{{.*}} + // ;warn:13:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableT: T? = null println(variableT) return body!!(variableName) @@ -18,7 +18,7 @@ private class ClassName { } } - // ;warn:21:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo + // ;warn:21:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo{{.*}} fun foo(var1: T, var2: ((T?) -> T?)?) { lock(var2, var1) } diff --git a/examples/kotlin-diktat/warn-dir/chapter1/SmallTest.kt b/examples/kotlin-diktat/warn-dir/chapter1/SmallTest.kt index b91c2da6c..44c8721ac 100644 --- a/examples/kotlin-diktat/warn-dir/chapter1/SmallTest.kt +++ b/examples/kotlin-diktat/warn-dir/chapter1/SmallTest.kt @@ -1,4 +1,4 @@ -// ;warn:1:1: [FILE_CONTAINS_ONLY_COMMENTS] empty files or files that contain only comments should be avoided: file contains no code (cannot be auto-corrected) -// ;warn:1:1: [HEADER_MISSING_IN_NON_SINGLE_CLASS_FILE] files that contain multiple or no classes should contain description of what is inside of this file: there are 0 declared classes and/or objects (cannot be auto-corrected) -// ;warn:4:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save +// ;warn:1:1: [FILE_CONTAINS_ONLY_COMMENTS] empty files or files that contain only comments should be avoided: file contains no code (cannot be auto-corrected){{.*}} +// ;warn:1:1: [HEADER_MISSING_IN_NON_SINGLE_CLASS_FILE] files that contain multiple or no classes should contain description of what is inside of this file: there are 0 declared classes and/or objects (cannot be auto-corrected){{.*}} +// ;warn:4:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} package com.saveourtool.diktat.test.paragraph1.naming.generic diff --git a/examples/kotlin-diktat/warn-dir/chapter2/GenericFunctionTest.kt b/examples/kotlin-diktat/warn-dir/chapter2/GenericFunctionTest.kt index c1cf3373e..f6f72820e 100644 --- a/examples/kotlin-diktat/warn-dir/chapter2/GenericFunctionTest.kt +++ b/examples/kotlin-diktat/warn-dir/chapter2/GenericFunctionTest.kt @@ -1,15 +1,15 @@ -// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName -// ;warn:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save +// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName{{.*}} +// ;warn:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} package com.saveourtool.diktat.test.paragraph1.naming.generic private class ClassName { private fun lock(body: ((Template?) -> T?)?, value: Template?): T? { try { - // ;warn:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected) - // ;warn:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected){{.*}} + // ;warn:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableName: Template? = null - // ;warn:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT - // ;warn:$line+1:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT{{.*}} + // ;warn:$line+1:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableT: T? = null println(variableT) return body!!(variableName) @@ -18,7 +18,7 @@ private class ClassName { } } - // ;warn:21:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo + // ;warn:21:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo{{.*}} fun foo(var1: T, var2: ((T?) -> T?)?) { lock(var2, var1) } diff --git a/examples/kotlin-diktat/warn-dir/chapter3/GenericFunctionTest.kt b/examples/kotlin-diktat/warn-dir/chapter3/GenericFunctionTest.kt index 0311bcc2c..db16a93ad 100644 --- a/examples/kotlin-diktat/warn-dir/chapter3/GenericFunctionTest.kt +++ b/examples/kotlin-diktat/warn-dir/chapter3/GenericFunctionTest.kt @@ -1,15 +1,15 @@ -// ;warn:$line:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName -// ;warn:$line+1:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save +// ;warn:$line:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName{{.*}} +// ;warn:$line+1:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} package com.saveourtool.diktat.test.paragraph1.naming.generic private class ClassName { private fun lock(body: ((Template?) -> T?)?, value: Template?): T? { try { - // ;warn:$line+2:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected) - // ;warn:$line+1:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:$line+2:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected){{.*}} + // ;warn:$line+1:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableName: Template? = null - // ;warn:$line+2:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT - // ;warn:$line+1:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:$line+2:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT{{.*}} + // ;warn:$line+1:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableT: T? = null println(variableT) return body!!(variableName) @@ -19,7 +19,7 @@ private class ClassName { } // comment comment comment - // ;warn:$line-1:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo + // ;warn:$line-1:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo{{.*}} fun foo(var1: T, var2: ((T?) -> T?)?) { lock(var2, var1) } diff --git a/examples/kotlin-diktat/warn-dir/chapter4/GenericFunctionTest.kt b/examples/kotlin-diktat/warn-dir/chapter4/GenericFunctionTest.kt index 6948a461e..6720ace5c 100644 --- a/examples/kotlin-diktat/warn-dir/chapter4/GenericFunctionTest.kt +++ b/examples/kotlin-diktat/warn-dir/chapter4/GenericFunctionTest.kt @@ -1,4 +1,4 @@ -/* ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName */ +/* ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName{{.*}} */ package com.saveourtool.save.test.paragraph1.naming.generic private class ClassName { @@ -7,7 +7,7 @@ private class ClassName { val variableName: Template /* ;warn:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should * be in lowerCamelCase and should contain only latin (ASCII) - * letters or numbers and should start from lower letter: variableT + * letters or numbers and should start from lower letter: variableT{{.*}} * */ val variableT: T println(variableT) @@ -18,7 +18,7 @@ private class ClassName { } /* ;warn:20:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected - * functions should have Kdoc with proper tags: foo */ + * functions should have Kdoc with proper tags: foo{{.*}} */ fun foo(var1: T, var2: ((T?) -> T?)?) { lock(var2, var1) } diff --git a/examples/kotlin-diktat/warn-dir/save.toml b/examples/kotlin-diktat/warn-dir/save.toml index 4c92e7593..56c7352f8 100644 --- a/examples/kotlin-diktat/warn-dir/save.toml +++ b/examples/kotlin-diktat/warn-dir/save.toml @@ -1,5 +1,5 @@ [general] - execCmd = "java -jar ktlint-old --disabled_rules=standard -R diktat-old.jar" + execCmd = "java -jar ktlint --disabled_rules=standard -R diktat.jar" tags = ["warn"] description = "Test for directory mode" diff --git a/examples/kotlin-diktat/warn/chapter1/EnumValueSnakeCaseTest.kt b/examples/kotlin-diktat/warn/chapter1/EnumValueSnakeCaseTest.kt index 6aa3ef00b..83a69f7c5 100644 --- a/examples/kotlin-diktat/warn/chapter1/EnumValueSnakeCaseTest.kt +++ b/examples/kotlin-diktat/warn/chapter1/EnumValueSnakeCaseTest.kt @@ -1,15 +1,119 @@ -package com.saveourtool.diktat.test.resources.test.paragraph1.naming.enum_ +@file:Suppress("PACKAGE_NAME_INCORRECT_PREFIX") -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) -// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +package com.saveourtool.save.test.resources.test.paragraph1.naming.enum_ + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// =============================================================== // + + + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} +enum class EnumValueSnakeCaseTest { + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} + paSC_SAl_l, + + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} + PascAsl_f + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} + + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} +} + +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} enum class EnumValueSnakeCaseTest { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} paSC_SAl_l, - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} - // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} + // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} } diff --git a/examples/kotlin-diktat/warn/chapter1/GenericFunctionTest.kt b/examples/kotlin-diktat/warn/chapter1/GenericFunctionTest.kt index 5420aa628..22bb156b5 100644 --- a/examples/kotlin-diktat/warn/chapter1/GenericFunctionTest.kt +++ b/examples/kotlin-diktat/warn/chapter1/GenericFunctionTest.kt @@ -1,15 +1,15 @@ -// ;warn:3:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save -// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName +// ;warn:3:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} +// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName{{.*}} package com.saveourtool.diktat.test.paragraph1.naming.generic private class ClassName { private fun lock(body: ((Template?) -> T?)?, value: Template?): T? { try { - // ;warn:10:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected) - // ;warn:10:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:10:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected){{.*}} + // ;warn:10:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableName: Template? = null - // ;warn:13:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT - // ;warn:13:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:13:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT{{.*}} + // ;warn:13:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableT: T? = null println(variableT) return body!!(variableName) @@ -18,7 +18,7 @@ private class ClassName { } } - // ;warn:21:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo + // ;warn:21:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo{{.*}} fun foo(var1: T, var2: ((T?) -> T?)?) { lock(var2, var1) } diff --git a/examples/kotlin-diktat/warn/chapter1/IgnoreLinesTest/EnumTestDetection.kt b/examples/kotlin-diktat/warn/chapter1/IgnoreLinesTest/EnumTestDetection.kt index b5de76a1b..3eff30912 100644 --- a/examples/kotlin-diktat/warn/chapter1/IgnoreLinesTest/EnumTestDetection.kt +++ b/examples/kotlin-diktat/warn/chapter1/IgnoreLinesTest/EnumTestDetection.kt @@ -1,16 +1,16 @@ package com.saveourtool.diktat.test.resources.test.paragraph1.naming.enum_ -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumTestDetection (cannot be auto-corrected) -// ;warn:30: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumTestDetection (cannot be auto-corrected){{.*}} +// ;warn:30: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} enum class EnumTestDetection { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} paSC_SAl_l, - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} } -// ;warn:0:0: [YOU SHOULD NOT SEE THIS] this warning should not be shown +// ;warn:0:0: [YOU SHOULD NOT SEE THIS] this warning should not be shown{{.*}} diff --git a/examples/kotlin-diktat/warn/chapter1/TestMatchOnlyByLineColumn/EnumValueSnakeCaseTest.kt b/examples/kotlin-diktat/warn/chapter1/TestMatchOnlyByLineColumn/EnumValueSnakeCaseTest.kt index 368fc8c3c..336989bb7 100644 --- a/examples/kotlin-diktat/warn/chapter1/TestMatchOnlyByLineColumn/EnumValueSnakeCaseTest.kt +++ b/examples/kotlin-diktat/warn/chapter1/TestMatchOnlyByLineColumn/EnumValueSnakeCaseTest.kt @@ -2,7 +2,7 @@ package com.saveourtool.diktat.test.resources.test.paragraph1.naming.enum_ // ;warn:3:1 // ;warn:6:35 -// ;warn:10:5: This message will be ignored anyway, don't matter what this line contain +// ;warn:10:5: This message will be ignored anyway, don't matter what this line contain{{.*}} enum class EnumValueSnakeCaseTest { // ;warn:$line+1:5 paSC_SAl_l, diff --git a/examples/kotlin-diktat/warn/chapter1/TestResultsFileTest/EnumTestDetection.kt b/examples/kotlin-diktat/warn/chapter1/TestResultsFileTest/EnumTestDetection.kt index ae3341a88..6006920b6 100644 --- a/examples/kotlin-diktat/warn/chapter1/TestResultsFileTest/EnumTestDetection.kt +++ b/examples/kotlin-diktat/warn/chapter1/TestResultsFileTest/EnumTestDetection.kt @@ -1,15 +1,15 @@ package com.saveourtool.diktat.test.resources.test.paragraph1.naming.enum_ -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumTestDetection (cannot be auto-corrected) -// ;warn:30: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumTestDetection (cannot be auto-corrected){{.*}} +// ;warn:30: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} enum class EnumTestDetection { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} paSC_SAl_l, - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} } diff --git a/examples/kotlin-diktat/warn/chapter1/TestsWithRegex/EnumTestDetection.kt b/examples/kotlin-diktat/warn/chapter1/TestsWithRegex/EnumTestDetection.kt index ae3341a88..6006920b6 100644 --- a/examples/kotlin-diktat/warn/chapter1/TestsWithRegex/EnumTestDetection.kt +++ b/examples/kotlin-diktat/warn/chapter1/TestsWithRegex/EnumTestDetection.kt @@ -1,15 +1,15 @@ package com.saveourtool.diktat.test.resources.test.paragraph1.naming.enum_ -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumTestDetection (cannot be auto-corrected) -// ;warn:30: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumTestDetection (cannot be auto-corrected){{.*}} +// ;warn:30: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} enum class EnumTestDetection { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} paSC_SAl_l, - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} } diff --git a/examples/kotlin-diktat/warn/chapter1/TestsWithRegex/NoMatchingTests/EnumTestDetection.kt b/examples/kotlin-diktat/warn/chapter1/TestsWithRegex/NoMatchingTests/EnumTestDetection.kt index ae3341a88..6006920b6 100644 --- a/examples/kotlin-diktat/warn/chapter1/TestsWithRegex/NoMatchingTests/EnumTestDetection.kt +++ b/examples/kotlin-diktat/warn/chapter1/TestsWithRegex/NoMatchingTests/EnumTestDetection.kt @@ -1,15 +1,15 @@ package com.saveourtool.diktat.test.resources.test.paragraph1.naming.enum_ -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumTestDetection (cannot be auto-corrected) -// ;warn:30: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumTestDetection (cannot be auto-corrected){{.*}} +// ;warn:30: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} enum class EnumTestDetection { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} paSC_SAl_l, - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} } diff --git a/examples/kotlin-diktat/warn/chapter1/TestsWithRegex/NoMatchingTests/GenericFunctionTest.kt b/examples/kotlin-diktat/warn/chapter1/TestsWithRegex/NoMatchingTests/GenericFunctionTest.kt index 5420aa628..22bb156b5 100644 --- a/examples/kotlin-diktat/warn/chapter1/TestsWithRegex/NoMatchingTests/GenericFunctionTest.kt +++ b/examples/kotlin-diktat/warn/chapter1/TestsWithRegex/NoMatchingTests/GenericFunctionTest.kt @@ -1,15 +1,15 @@ -// ;warn:3:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save -// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName +// ;warn:3:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} +// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName{{.*}} package com.saveourtool.diktat.test.paragraph1.naming.generic private class ClassName { private fun lock(body: ((Template?) -> T?)?, value: Template?): T? { try { - // ;warn:10:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected) - // ;warn:10:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:10:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected){{.*}} + // ;warn:10:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableName: Template? = null - // ;warn:13:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT - // ;warn:13:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:13:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT{{.*}} + // ;warn:13:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableT: T? = null println(variableT) return body!!(variableName) @@ -18,7 +18,7 @@ private class ClassName { } } - // ;warn:21:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo + // ;warn:21:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo{{.*}} fun foo(var1: T, var2: ((T?) -> T?)?) { lock(var2, var1) } diff --git a/examples/kotlin-diktat/warn/chapter1/ThisShouldAlwaysFailTest.kt b/examples/kotlin-diktat/warn/chapter1/ThisShouldAlwaysFailTest.kt index cb9319669..976687660 100644 --- a/examples/kotlin-diktat/warn/chapter1/ThisShouldAlwaysFailTest.kt +++ b/examples/kotlin-diktat/warn/chapter1/ThisShouldAlwaysFailTest.kt @@ -1,6 +1,6 @@ package com.saveourtool.save.test.resources.test.paragraph1.naming.enum_ -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: ThisShouldAlwaysFailTest (cannot be auto-corrected) +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: ThisShouldAlwaysFailTest (cannot be auto-corrected){{.*}} enum class ThisShouldAlwaysFailTest { - // ;warn:8:1: [DUMMY_ERROR] this error should not match + // ;warn:8:1: [DUMMY_ERROR] this error should not match{{.*}} } diff --git a/examples/kotlin-diktat/warn/chapter2/EnumValueSnakeCaseTest.kt b/examples/kotlin-diktat/warn/chapter2/EnumValueSnakeCaseTest.kt index 6aa3ef00b..7f554e1b9 100644 --- a/examples/kotlin-diktat/warn/chapter2/EnumValueSnakeCaseTest.kt +++ b/examples/kotlin-diktat/warn/chapter2/EnumValueSnakeCaseTest.kt @@ -1,15 +1,15 @@ package com.saveourtool.diktat.test.resources.test.paragraph1.naming.enum_ -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected) -// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon +// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} +// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} +// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} enum class EnumValueSnakeCaseTest { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l + // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} paSC_SAl_l, - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f + // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma + // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} } diff --git a/examples/kotlin-diktat/warn/chapter2/GenericFunctionTest.kt b/examples/kotlin-diktat/warn/chapter2/GenericFunctionTest.kt index 5420aa628..22bb156b5 100644 --- a/examples/kotlin-diktat/warn/chapter2/GenericFunctionTest.kt +++ b/examples/kotlin-diktat/warn/chapter2/GenericFunctionTest.kt @@ -1,15 +1,15 @@ -// ;warn:3:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save -// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName +// ;warn:3:9: [PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: com.saveourtool.save{{.*}} +// ;warn:1:1: [FILE_NAME_MATCH_CLASS] file name is incorrect - it should match with the class described in it if there is the only one class declared: GenericFunctionTest.kt vs ClassName{{.*}} package com.saveourtool.diktat.test.paragraph1.naming.generic private class ClassName { private fun lock(body: ((Template?) -> T?)?, value: Template?): T? { try { - // ;warn:10:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected) - // ;warn:10:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:10:13: [LOCAL_VARIABLE_EARLY_DECLARATION] local variables should be declared close to the line where they are first used: is declared on line <10> and is used for the first time on line <15> (cannot be auto-corrected){{.*}} + // ;warn:10:43: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableName: Template? = null - // ;warn:13:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT - // ;warn:13:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected) + // ;warn:13:17: [VARIABLE_NAME_INCORRECT_FORMAT] variable name should be in lowerCamelCase and should contain only latin (ASCII) letters or numbers and should start from lower letter: variableT{{.*}} + // ;warn:13:33: [NULLABLE_PROPERTY_TYPE] try to avoid use of nullable types: initialize explicitly (cannot be auto-corrected){{.*}} val variableT: T? = null println(variableT) return body!!(variableName) @@ -18,7 +18,7 @@ private class ClassName { } } - // ;warn:21:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo + // ;warn:21:5: [MISSING_KDOC_ON_FUNCTION] all public, internal and protected functions should have Kdoc with proper tags: foo{{.*}} fun foo(var1: T, var2: ((T?) -> T?)?) { lock(var2, var1) } diff --git a/gradle.properties b/gradle.properties index edf424555..a7b43080f 100644 --- a/gradle.properties +++ b/gradle.properties @@ -14,3 +14,6 @@ kotlin.native.cacheKind.linuxX64=none kotlin.mpp.hierarchicalStructureSupport=true # making custom cinterop libraries available in shared source sets kotlin.mpp.enableCInteropCommonization=true + +gprUser=akuleshov7 +gprKey=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 \ No newline at end of file diff --git a/save-cli/build.gradle.kts b/save-cli/build.gradle.kts index 92429d54c..f6530466c 100644 --- a/save-cli/build.gradle.kts +++ b/save-cli/build.gradle.kts @@ -84,7 +84,6 @@ kotlin { tasks.withType().configureEach { dependsOn(":save-core:downloadTestResources") - dependsOn(":save-core:downloadOldTestResources") } // disable building of some binaries to speed up build diff --git a/save-cli/src/jvmTest/kotlin/com/saveourtool/save/cli/GeneralTest.kt b/save-cli/src/jvmTest/kotlin/com/saveourtool/save/cli/GeneralTest.kt index 5b033fa0d..b7d5e9106 100644 --- a/save-cli/src/jvmTest/kotlin/com/saveourtool/save/cli/GeneralTest.kt +++ b/save-cli/src/jvmTest/kotlin/com/saveourtool/save/cli/GeneralTest.kt @@ -62,8 +62,8 @@ class GeneralTest { assertTrue(fs.exists(destination)) // Check for existence of diktat and ktlint - assertTrue(fs.exists((examplesDir.toPath() / "diktat-old.jar"))) - assertTrue(fs.exists((examplesDir.toPath() / "ktlint-old"))) + assertTrue(fs.exists((examplesDir.toPath() / "diktat.jar"))) + assertTrue(fs.exists((examplesDir.toPath() / "ktlint"))) // Make sure, that we will check report, which will be obtained after current execution; remove old report if exist val reportFile = examplesDir.toPath() / "save.out.json".toPath() @@ -95,7 +95,6 @@ class GeneralTest { reports.forEach { report -> report.pluginExecutions.forEach { pluginExecution -> pluginExecution.testResults.find { result -> - println(result.status) // FixMe: if we will have other failing tests - we will make the logic less hardcoded result.resources.test.name != "GarbageTest.kt" && result.resources.test.name != "ThisShouldAlwaysFailTest.kt" && diff --git a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt index 48ec3bc3e..a6c460305 100644 --- a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt +++ b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt @@ -108,6 +108,7 @@ class ProcessBuilder(private val useInternalRedirections: Boolean, private val f logDebug("Executing: $cmd with timeout $timeOutMillis ms") val status = try { processBuilderInternal.exec(cmd, timeOutMillis) + } catch (ex: ProcessTimeoutException) { fs.deleteRecursively(tmpDir) throw ex @@ -115,8 +116,10 @@ class ProcessBuilder(private val useInternalRedirections: Boolean, private val f fs.deleteRecursively(tmpDir) logErrorAndThrowProcessBuilderException(ex.message ?: "Couldn't execute $cmd") } + val stdout = fs.readLines(stdoutFile) val stderr = fs.readLines(stderrFile) + fs.myDeleteRecursively(tmpDir) logTrace("Removed temp directory $tmpDir") if (stderr.isNotEmpty()) { diff --git a/save-core/build.gradle.kts b/save-core/build.gradle.kts index d81067ec0..b04a11910 100644 --- a/save-core/build.gradle.kts +++ b/save-core/build.gradle.kts @@ -71,23 +71,6 @@ tasks.withType>().forEach { it.dependsOn(generateVersionFileTaskProvider) } -tasks.register("downloadOldTestResources") { - src(listOf( - Versions.IntegrationTest.oldKtlintLink, - Versions.IntegrationTest.oldDiktatLink, - )) - dest("../examples/kotlin-diktat") - doLast { - file("../examples/kotlin-diktat/diktat-${Versions.IntegrationTest.oldDiktat}.jar").renameTo( - file("../examples/kotlin-diktat/diktat-old.jar") - ) - - file("../examples/kotlin-diktat/ktlint").renameTo( - file("../examples/kotlin-diktat/ktlint-old") - ) - } -} - tasks.register("downloadTestResources") { src(listOf( Versions.IntegrationTest.ktlintLink, @@ -105,14 +88,11 @@ val cleanupTask = tasks.register("cleanupTestResources") { this.dependsOn(":save-cli:jvmTest") mustRunAfter(tasks.withType()) doFirst { - file("../examples/kotlin-diktat/ktlint-old").delete() file("../examples/kotlin-diktat/ktlint").delete() - file("../examples/kotlin-diktat/diktat-old.jar").delete() file("../examples/kotlin-diktat/diktat.jar").delete() } } tasks.withType().configureEach { dependsOn("downloadTestResources") - dependsOn("downloadOldTestResources") finalizedBy("cleanupTestResources") } diff --git a/save-core/src/commonNonJsTest/kotlin/com/saveourtool/save/core/test/utils/TestUtilsCommon.kt b/save-core/src/commonNonJsTest/kotlin/com/saveourtool/save/core/test/utils/TestUtilsCommon.kt index 498f83267..787327234 100644 --- a/save-core/src/commonNonJsTest/kotlin/com/saveourtool/save/core/test/utils/TestUtilsCommon.kt +++ b/save-core/src/commonNonJsTest/kotlin/com/saveourtool/save/core/test/utils/TestUtilsCommon.kt @@ -11,6 +11,7 @@ import com.saveourtool.save.core.config.LogType import com.saveourtool.save.core.config.OutputStreamType import com.saveourtool.save.core.config.ReportType import com.saveourtool.save.core.config.SaveProperties +import com.saveourtool.save.core.logging.logType import com.saveourtool.save.core.result.Fail import com.saveourtool.save.core.result.Ignored import com.saveourtool.save.core.result.Pass @@ -50,15 +51,17 @@ fun runTestsWithDiktat( mutableTestDir.add(0, "../examples/kotlin-diktat/") val saveProperties = SaveProperties( - logType = LogType.ALL, testFiles = mutableTestDir, reportType = ReportType.TEST, resultOutput = OutputStreamType.STDOUT, ).apply { addProperties() } + + // logger is not set from save properties without a config reader, need to set it explicily + logType.set(LogType.ALL) // In this test we need to merge with emulated empty save.properties file in aim to use default values, // since initially all fields are null - val testReporter = Save(saveProperties.mergeConfigWithPriorityToThis(SaveProperties()), FileSystem.SYSTEM) - .performAnalysis() as TestReporter + val save = Save(saveProperties.mergeConfigWithPriorityToThis(SaveProperties()), FileSystem.SYSTEM) + val testReporter = save.performAnalysis() as TestReporter assertEquals(numberOfTests, testReporter.results.size) testReporter.results.forEach { test -> diff --git a/save-plugins/warn-plugin/src/commonMain/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtils.kt b/save-plugins/warn-plugin/src/commonMain/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtils.kt index c702b5089..5c4d93bdc 100644 --- a/save-plugins/warn-plugin/src/commonMain/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtils.kt +++ b/save-plugins/warn-plugin/src/commonMain/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtils.kt @@ -19,21 +19,26 @@ fun String.findDelimitedSubStringsWith(openingDelimiter: String, closingDelimite // finding first delimited group in the initial string var delimitedGroup = this.findFirstDelimitedSubStringBy(openingDelimiter, closingDelimiter) var nextPartOfString = this - val result = if (delimitedGroup != delimiterNotFound) mutableMapOf(delimitedGroup) else mutableMapOf() - while (true) { - // offset that is used to restore indexes in the initial string (as the logic below is applied to substring) - val offset = delimitedGroup.second + closingDelimiter.length - // substring without a part of a string that was already processed (shifted by offset) - nextPartOfString = nextPartOfString.substring(offset, nextPartOfString.length) - delimitedGroup = nextPartOfString.findFirstDelimitedSubStringBy(openingDelimiter, closingDelimiter) - // no need to process if there are no delimiters in the substring - if (delimitedGroup == delimiterNotFound) { - break + // offset that is used to restore indexes in the initial string (as the logic below is applied to substring) + var offset = delimitedGroup.second + closingDelimiter.length + + return if (delimitedGroup == delimiterNotFound) { + mutableMapOf() + } else { + val result = mutableMapOf(delimitedGroup) + while (true) { + // substring without a part of a string that was already processed (shifted by offset) + nextPartOfString = nextPartOfString.substring(delimitedGroup.second + closingDelimiter.length, nextPartOfString.length) + delimitedGroup = nextPartOfString.findFirstDelimitedSubStringBy(openingDelimiter, closingDelimiter) + if (delimitedGroup == delimiterNotFound) { + break + } + result[offset + delimitedGroup.first] = offset + delimitedGroup.second + // updating the offset for + offset += delimitedGroup.second + closingDelimiter.length } - result[offset + delimitedGroup.first] = offset + delimitedGroup.second + result } - - return result } /** @@ -41,6 +46,8 @@ fun String.findDelimitedSubStringsWith(openingDelimiter: String, closingDelimite * For example, if openingDelimiter = ( , closingDelimiter = ) , this = aaa(bbb)ccc(eee) => * method will return indexes delimited string (start inclusive, end exclusive) - bbb - Pair(4, 6), counted from 0. * + * WHY NOT TO USE: `substringAfter("{").substringBefore("}")`? Because we need to raise proper error during parsing + * * Returns DELIMITER_NOT_FOUND - Pair(-1, -1) if no opening/closing group found * * @param openingDelimiter opening group of symbols that is used to separate pattern diff --git a/save-plugins/warn-plugin/src/commonNonJsTest/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtilsTest.kt b/save-plugins/warn-plugin/src/commonNonJsTest/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtilsTest.kt index efb476252..b38e18a55 100644 --- a/save-plugins/warn-plugin/src/commonNonJsTest/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtilsTest.kt +++ b/save-plugins/warn-plugin/src/commonNonJsTest/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtilsTest.kt @@ -56,4 +56,17 @@ class StringUtilsTest { expected = "B BBB" assertTrue { regex.matches(expected) } } + + @Test + fun `regression with regular expressions`() { + var test = "aaa{{ should }}bbb{{ UPPER_CASE }}ccc{{.*}}" + var regex = test.createRegexFromString("{{", "}}") + + println(regex) + + test = "[ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}}" + regex = test.createRegexFromString("{{", "}}") + + println(regex) + } } From 78d41a087cda6c171b185c22b7884cc17da261ba Mon Sep 17 00:00:00 2001 From: Andrey Kuleshov Date: Fri, 17 Jun 2022 23:37:27 +0300 Subject: [PATCH 3/6] ### What's done: - removed "old" binaries --- gradle.properties | 3 --- 1 file changed, 3 deletions(-) diff --git a/gradle.properties b/gradle.properties index a7b43080f..edf424555 100644 --- a/gradle.properties +++ b/gradle.properties @@ -14,6 +14,3 @@ kotlin.native.cacheKind.linuxX64=none kotlin.mpp.hierarchicalStructureSupport=true # making custom cinterop libraries available in shared source sets kotlin.mpp.enableCInteropCommonization=true - -gprUser=akuleshov7 -gprKey=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 \ No newline at end of file From 8b68a0375da3ff7d411ee1c504909a7d62fa0926 Mon Sep 17 00:00:00 2001 From: Andrey Kuleshov Date: Mon, 20 Jun 2022 20:49:30 +0300 Subject: [PATCH 4/6] ### What's done: - removed "old" binaries --- .../kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt | 5 ++--- .../saveourtool/save/plugin/warn/utils/StringUtilsTest.kt | 4 ++-- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt index a0997a841..a6c460305 100644 --- a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt +++ b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt @@ -87,7 +87,8 @@ class ProcessBuilder(private val useInternalRedirections: Boolean, private val f } // Temporary directory for stderr and stdout (posix `system()` can't separate streams, so we do it ourselves) - val tmpDir = "D:/".toPath() + val tmpDir = (FileSystem.SYSTEM_TEMPORARY_DIRECTORY / + ("ProcessBuilder_" + Clock.System.now().toEpochMilliseconds()).toPath()) logTrace("Creating temp directory: $tmpDir") // Path to stdout file val stdoutFile = tmpDir / "stdout.txt" @@ -117,8 +118,6 @@ class ProcessBuilder(private val useInternalRedirections: Boolean, private val f } val stdout = fs.readLines(stdoutFile) - - println("HERE $stdout") val stderr = fs.readLines(stderrFile) fs.myDeleteRecursively(tmpDir) diff --git a/save-plugins/warn-plugin/src/commonNonJsTest/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtilsTest.kt b/save-plugins/warn-plugin/src/commonNonJsTest/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtilsTest.kt index b38e18a55..f45ecd477 100644 --- a/save-plugins/warn-plugin/src/commonNonJsTest/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtilsTest.kt +++ b/save-plugins/warn-plugin/src/commonNonJsTest/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtilsTest.kt @@ -62,11 +62,11 @@ class StringUtilsTest { var test = "aaa{{ should }}bbb{{ UPPER_CASE }}ccc{{.*}}" var regex = test.createRegexFromString("{{", "}}") - println(regex) + assertTrue { regex.matches("aaa should bbb UPPER_CASE ccc TESTTEST]]]") } test = "[ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}}" regex = test.createRegexFromString("{{", "}}") - println(regex) + assertTrue { regex.matches("[ENUM_VALUE] enum values should be in selected UPPER_CASE snake/PascalCase format: PascAsl_f{{.*}}") } } } From 629ba6b0ea50542832ad34448328f37059c6c64e Mon Sep 17 00:00:00 2001 From: Andrey Kuleshov Date: Mon, 20 Jun 2022 23:56:41 +0300 Subject: [PATCH 5/6] ### What's done: - removed "old" binaries --- .../save/buildutils/JacocoConfiguration.kt | 2 +- .../saveourtool/save/chapter2/Bug2Expected.kt | 9 +- .../warn/chapter1/EnumValueSnakeCaseTest.kt | 107 +----------------- ...mValueSnakeCaseTest.kt => TimeoutTest1.kt} | 0 ...GenericFunctionTest.kt => TimeoutTest2.kt} | 0 .../save/core/config/TestConfig.kt | 16 +-- .../saveourtool/save/core/plugin/Plugin.kt | 7 +- 7 files changed, 17 insertions(+), 124 deletions(-) rename examples/kotlin-diktat/warn/chapter2/{EnumValueSnakeCaseTest.kt => TimeoutTest1.kt} (100%) rename examples/kotlin-diktat/warn/chapter2/{GenericFunctionTest.kt => TimeoutTest2.kt} (100%) diff --git a/buildSrc/src/main/kotlin/com/saveourtool/save/buildutils/JacocoConfiguration.kt b/buildSrc/src/main/kotlin/com/saveourtool/save/buildutils/JacocoConfiguration.kt index 61f91d9f3..030adf203 100644 --- a/buildSrc/src/main/kotlin/com/saveourtool/save/buildutils/JacocoConfiguration.kt +++ b/buildSrc/src/main/kotlin/com/saveourtool/save/buildutils/JacocoConfiguration.kt @@ -27,7 +27,7 @@ fun Project.configureJacoco() { apply() configure { - toolVersion = "0.8.7" + toolVersion = "0.8.8" } val kotlin: KotlinMultiplatformExtension = extensions.getByType() diff --git a/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter2/Bug2Expected.kt b/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter2/Bug2Expected.kt index 34b388226..82b161ddc 100644 --- a/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter2/Bug2Expected.kt +++ b/examples/kotlin-diktat/fix_and_warn/smoke/src/main/kotlin/com/saveourtool/save/chapter2/Bug2Expected.kt @@ -32,16 +32,11 @@ internal fun createWithFile( private fun foo(node: ASTNode) { when (node.elementType) { CLASS, FUN, PRIMARY_CONSTRUCTOR, SECONDARY_CONSTRUCTOR -> checkAnnotation(node) - else -> { - // this is a generated else block - } } val qwe = a && - // ;warn:41:1: [WRONG_INDENTATION] only spaces are allowed for indentation and each indentation should equal to 4 spaces (tabs are not allowed): expected 12 but was 8{{.*}} - b + b val qwe = a && - // ;warn:44:1: [WRONG_INDENTATION] only spaces are allowed for indentation and each indentation should equal to 4 spaces (tabs are not allowed): expected 12 but was 8{{.*}} - b + b // comment if (x) { diff --git a/examples/kotlin-diktat/warn/chapter1/EnumValueSnakeCaseTest.kt b/examples/kotlin-diktat/warn/chapter1/EnumValueSnakeCaseTest.kt index 83a69f7c5..319b424f3 100644 --- a/examples/kotlin-diktat/warn/chapter1/EnumValueSnakeCaseTest.kt +++ b/examples/kotlin-diktat/warn/chapter1/EnumValueSnakeCaseTest.kt @@ -2,9 +2,9 @@ package com.saveourtool.save.test.resources.test.paragraph1.naming.enum_ -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} +// ;warn:5:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} // ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} +// ;warn:12:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} enum class EnumValueSnakeCaseTest { // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} paSC_SAl_l, @@ -13,107 +13,4 @@ enum class EnumValueSnakeCaseTest { PascAsl_f // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} - // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} -} - -// =============================================================== // - - - -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} -// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} -enum class EnumValueSnakeCaseTest { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} - paSC_SAl_l, - - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} - PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} - - // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} -} - -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} -// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} -enum class EnumValueSnakeCaseTest { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} - paSC_SAl_l, - - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} - PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} - - // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} -} - -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} -// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} -enum class EnumValueSnakeCaseTest { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} - paSC_SAl_l, - - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} - PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} - - // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} -} - -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} -// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} -enum class EnumValueSnakeCaseTest { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} - paSC_SAl_l, - - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} - PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} - - // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} -} - -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} -// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} -enum class EnumValueSnakeCaseTest { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} - paSC_SAl_l, - - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} - PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} - - // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} -} - -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} -// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} -enum class EnumValueSnakeCaseTest { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} - paSC_SAl_l, - - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} - PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} - - // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} -} - -// ;warn:3:1: [MISSING_KDOC_TOP_LEVEL] all public and internal top-level classes and functions should have Kdoc: EnumValueSnakeCaseTest (cannot be auto-corrected){{.*}} -// ;warn:35: [WRONG_DECLARATIONS_ORDER] declarations of constants and enum members should be sorted alphabetically: enum entries order is incorrect{{.*}} -// ;warn:10:5: [ENUMS_SEPARATED] enum is incorrectly formatted: enums must end with semicolon{{.*}} -enum class EnumValueSnakeCaseTest { - // ;warn:$line+1:5: [ENUM_VALUE] enum values should be{{ in }}selected UPPER_CASE snake/PascalCase format: paSC_SAl_l{{.*}} - paSC_SAl_l, - - // ;warn:5: [ENUM_VALUE] enum values{{ should }}be in selected{{ UPPER_CASE }}snake/PascalCase format: PascAsl_f{{.*}} - PascAsl_f - // ;warn:$line-2:5: [ENUMS_SEPARATED] enum is incorrectly formatted: last enum entry must end with a comma{{.*}} - - // ;warn:1:9: {{.*}}[PACKAGE_NAME_INCORRECT_PREFIX] package name should start from company's domain: org.cqfn.save{{.*}} } diff --git a/examples/kotlin-diktat/warn/chapter2/EnumValueSnakeCaseTest.kt b/examples/kotlin-diktat/warn/chapter2/TimeoutTest1.kt similarity index 100% rename from examples/kotlin-diktat/warn/chapter2/EnumValueSnakeCaseTest.kt rename to examples/kotlin-diktat/warn/chapter2/TimeoutTest1.kt diff --git a/examples/kotlin-diktat/warn/chapter2/GenericFunctionTest.kt b/examples/kotlin-diktat/warn/chapter2/TimeoutTest2.kt similarity index 100% rename from examples/kotlin-diktat/warn/chapter2/GenericFunctionTest.kt rename to examples/kotlin-diktat/warn/chapter2/TimeoutTest2.kt diff --git a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/config/TestConfig.kt b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/config/TestConfig.kt index a5ecadae2..4383a2752 100644 --- a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/config/TestConfig.kt +++ b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/config/TestConfig.kt @@ -146,8 +146,8 @@ data class TestConfig( .filter { plugin -> plugin.discoverTestFiles(directory).any().also { isNotEmpty -> if (!isNotEmpty) { - logDebug("Plugin <${plugin::class.simpleName}> in config file ${plugin.testConfig.location} has no test resources; " + - "it's config will only be used for inheritance") + logDebug("Plugin <${plugin::class.simpleName}> in config file ${plugin.testConfig.location} has no test resources in the same directory; " + + "it's config will only be used for inheritance of configuration to nested test suites") } } } @@ -165,10 +165,10 @@ data class TestConfig( * @return merged test config */ fun mergeConfigWithParents(): TestConfig { - logDebug("Start merging configs for ${this.location}") + logDebug("Merging configs (with parental configs from higher directory level) for ${this.location}") this.parentConfigs().toList().forEach { parentConfig -> - logTrace("Processing config ${parentConfig.location} for merging with ${this.location}") + logTrace("Using parental config ${parentConfig.location} to merge it with child config: ${this.location}") // return from the function if we stay at the root element of the plugin tree val parentalPlugins = parentConfig.pluginConfigs parentalPlugins.forEach { parentalPluginConfig -> @@ -179,11 +179,10 @@ data class TestConfig( } else { // else, we will merge plugin with a corresponding plugin from a parent config // we expect that there is only one plugin of such type, otherwise we will throw an exception - logTrace("Starting actual merge of ${parentalPluginConfig.type} from ${parentConfig.location} into $location") + logTrace("Starting merging process of ${parentalPluginConfig.type} from ${parentConfig.location} into $location") val mergedConfig = childConfigs.single().mergeWith(parentalPluginConfig) - logTrace("Finished actual merge of ${parentalPluginConfig.type} from ${parentConfig.location} into $location") + logTrace("Finished merging process of ${parentalPluginConfig.type} from ${parentConfig.location} into $location") this.pluginConfigs.set(this.pluginConfigs.indexOf(childConfigs.single()), mergedConfig) - logTrace("Added merged config ${parentalPluginConfig.type} from ${parentConfig.location} into $location") } } } @@ -194,10 +193,11 @@ data class TestConfig( * Method, which validates all plugin configs and set default values, if possible */ fun validateAndSetDefaults() { - logDebug("Start plugin validation for $location") pluginConfigs.forEachIndexed { index, config -> pluginConfigs[index] = config.validateAndSetDefaults() } + logDebug("Validated plugin configuration for [$location] " + + "(${pluginConfigs.map { it.type }.filterNot { it == TestConfigSections.GENERAL }})") } } diff --git a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/plugin/Plugin.kt b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/plugin/Plugin.kt index 0b5308706..c453b2f4e 100644 --- a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/plugin/Plugin.kt +++ b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/plugin/Plugin.kt @@ -116,9 +116,10 @@ abstract class Plugin( } } }.toList() - val notFoundTests = testFiles.filter { testFile -> testFile !in foundTests.map { foundTest -> foundTest.test.toString() } } - if (notFoundTests.isNotEmpty()) { - logDebug("The following tests were not found: $notFoundTests. Try to make sure you have specified the correct relative path to the files.") + val foundTestsInDir = foundTests.filter { testFile -> testFile.test.toString() in testFiles } + if (foundTests.isNotEmpty()) { + logDebug("Following tests have been detected for the current plugin and directory: " + + "${foundTestsInDir.map { it.test.toString()} }. ") } return foundTests.asSequence() } else { From cf0212c3b6f87d99dff097ab2b29b03165df213c Mon Sep 17 00:00:00 2001 From: Andrey Kuleshov Date: Tue, 21 Jun 2022 00:00:21 +0300 Subject: [PATCH 6/6] ### What's done: - removed "old" binaries --- gradle.properties | 4 +--- .../kotlin/com/saveourtool/save/core/config/TestConfig.kt | 2 +- .../kotlin/com/saveourtool/save/core/plugin/Plugin.kt | 2 +- .../kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt | 1 - .../com/saveourtool/save/plugin/warn/utils/StringUtils.kt | 2 +- .../com/saveourtool/save/plugin/warn/utils/StringUtilsTest.kt | 1 + 6 files changed, 5 insertions(+), 7 deletions(-) diff --git a/gradle.properties b/gradle.properties index 39f484e28..ff90fc38d 100644 --- a/gradle.properties +++ b/gradle.properties @@ -13,6 +13,4 @@ kotlin.mpp.stability.nowarn=true kotlin.native.cacheKind.linuxX64=none kotlin.mpp.hierarchicalStructureSupport=true # making custom cinterop libraries available in shared source sets -kotlin.mpp.enableCInteropCommonization=true -gprUser=akuleshov7 -gprKey=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 \ No newline at end of file +kotlin.mpp.enableCInteropCommonization=true \ No newline at end of file diff --git a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/config/TestConfig.kt b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/config/TestConfig.kt index 4383a2752..9ddf67919 100644 --- a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/config/TestConfig.kt +++ b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/config/TestConfig.kt @@ -197,7 +197,7 @@ data class TestConfig( pluginConfigs[index] = config.validateAndSetDefaults() } logDebug("Validated plugin configuration for [$location] " + - "(${pluginConfigs.map { it.type }.filterNot { it == TestConfigSections.GENERAL }})") + "(${pluginConfigs.map { it.type }.filterNot { it == TestConfigSections.GENERAL }})") } } diff --git a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/plugin/Plugin.kt b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/plugin/Plugin.kt index c453b2f4e..d0ac9f123 100644 --- a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/plugin/Plugin.kt +++ b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/plugin/Plugin.kt @@ -119,7 +119,7 @@ abstract class Plugin( val foundTestsInDir = foundTests.filter { testFile -> testFile.test.toString() in testFiles } if (foundTests.isNotEmpty()) { logDebug("Following tests have been detected for the current plugin and directory: " + - "${foundTestsInDir.map { it.test.toString()} }. ") + "${foundTestsInDir.map { it.test.toString() } }. ") } return foundTests.asSequence() } else { diff --git a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt index a6c460305..610d084c5 100644 --- a/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt +++ b/save-common/src/commonMain/kotlin/com/saveourtool/save/core/utils/ProcessBuilder.kt @@ -108,7 +108,6 @@ class ProcessBuilder(private val useInternalRedirections: Boolean, private val f logDebug("Executing: $cmd with timeout $timeOutMillis ms") val status = try { processBuilderInternal.exec(cmd, timeOutMillis) - } catch (ex: ProcessTimeoutException) { fs.deleteRecursively(tmpDir) throw ex diff --git a/save-plugins/warn-plugin/src/commonMain/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtils.kt b/save-plugins/warn-plugin/src/commonMain/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtils.kt index 5c4d93bdc..1c7ec165b 100644 --- a/save-plugins/warn-plugin/src/commonMain/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtils.kt +++ b/save-plugins/warn-plugin/src/commonMain/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtils.kt @@ -35,7 +35,7 @@ fun String.findDelimitedSubStringsWith(openingDelimiter: String, closingDelimite } result[offset + delimitedGroup.first] = offset + delimitedGroup.second // updating the offset for - offset += delimitedGroup.second + closingDelimiter.length + offset += delimitedGroup.second + closingDelimiter.length } result } diff --git a/save-plugins/warn-plugin/src/commonNonJsTest/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtilsTest.kt b/save-plugins/warn-plugin/src/commonNonJsTest/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtilsTest.kt index f45ecd477..e0b6a40ed 100644 --- a/save-plugins/warn-plugin/src/commonNonJsTest/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtilsTest.kt +++ b/save-plugins/warn-plugin/src/commonNonJsTest/kotlin/com/saveourtool/save/plugin/warn/utils/StringUtilsTest.kt @@ -58,6 +58,7 @@ class StringUtilsTest { } @Test + @Suppress("SAY_NO_TO_VAR") fun `regression with regular expressions`() { var test = "aaa{{ should }}bbb{{ UPPER_CASE }}ccc{{.*}}" var regex = test.createRegexFromString("{{", "}}")