Fixed smoke tests

diktat-rules/src/main/kotlin/com/saveourtool/diktat/ruleset/rules/chapter1/PackageNaming.kt

@@ -54,6 +54,11 @@
         configuration.domainName?.let {
             domainName = it
             if (node.elementType == PACKAGE_DIRECTIVE) {
+                println("Before")
+                println(
+                    node.treeParent.prettyPrint()
+                )
+                println("Before--END")
                 val filePath = node.getFilePath()
 
                 // getting all identifiers from existing package name into the list like [org, diktat, project]
@@ -77,6 +82,11 @@
                 checkPackageName(wordsInPackageName, node)
                 // fix in checkFilePathMatchesWithPackageName is much more aggressive than fixes in checkPackageName, they can conflict
                 checkFilePathMatchesWithPackageName(wordsInPackageName, realPackageName, node)
+                println("After")
+                println(
+                    node.treeParent.prettyPrint()
+                )
+                println("After--END")
             }
         } ?: if (visitorCounter.incrementAndGet() == 1) {
             log.error {

diktat-rules/src/test/kotlin/com/saveourtool/diktat/ruleset/chapter1/PackagePathFixTest.kt

@@ -1,12 +1,18 @@
 package com.saveourtool.diktat.ruleset.chapter1
 
 import com.saveourtool.diktat.common.config.rules.RulesConfig
+import com.saveourtool.diktat.ruleset.constants.Warnings
 import com.saveourtool.diktat.ruleset.rules.chapter1.PackageNaming
 import com.saveourtool.diktat.util.FixTestBase
 
 import generated.WarningNames
+import org.junit.jupiter.api.Assertions
 import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+import java.nio.file.Path
+import kotlin.io.path.createDirectories
+import kotlin.io.path.writeText
 
 class PackagePathFixTest : FixTestBase(
     "test/paragraph1/naming/package/src/main/kotlin",
@@ -68,4 +74,37 @@ class PackagePathFixTest : FixTestBase(
     fun `fix missing package name with a proper location`() {
         fixAndCompare("com/saveourtool/diktat/some/name/FixMissingExpected.kt", "com/saveourtool/diktat/some/name/FixMissingTest.kt")
     }
+
+    @Test
+    @Tag(WarningNames.PACKAGE_NAME_MISSING)
+    fun `several empty lines after package`(@TempDir tempDir: Path) {
+        fixAndCompareContent(
+            expectedContent = """
+                package com.saveourtool.diktat
+                /**
+                 * @param bar
+                 * @return something
+                 */
+                fun foo1(bar: Bar): Baz {
+                    // placeholder
+                }
+            """.trimIndent(),
+            actualContent = """
+                /**
+                 * @param bar
+                 * @return something
+                 */
+                fun foo1(bar: Bar): Baz {
+                    // placeholder
+                }
+            """.trimIndent(),
+            subFolder = "src/main/kotlin/com/saveourtool/diktat",
+            tempDir = tempDir,
+        ).also { result ->
+            Assertions.assertAll(
+                { Assertions.assertTrue(result.isSuccessful) },
+                { Assertions.assertEquals(result.expectedContentWithoutWarns, result.actualContent) }
+            )
+        }
+    }
 }

diktat-rules/src/test/kotlin/com/saveourtool/diktat/ruleset/chapter3/FileStructureRuleFixTest.kt

@@ -9,6 +9,10 @@ import com.saveourtool.diktat.util.FixTestBase
 import generated.WarningNames
 import org.junit.jupiter.api.Tag
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+import java.nio.file.Path
+import kotlin.io.path.createDirectories
+import kotlin.io.path.writeText
 
 class FileStructureRuleFixTest : FixTestBase("test/paragraph3/file_structure", ::FileStructureRule) {
     @Test
@@ -96,4 +100,50 @@ class FileStructureRuleFixTest : FixTestBase("test/paragraph3/file_structure", :
     fun `invalid move in kts files`() {
         fixAndCompare("ScriptPackageDirectiveExpected.kts", "ScriptPackageDirectiveTest.kts")
     }
+
+    @Test
+    @Tag(WarningNames.FILE_NO_BLANK_LINE_BETWEEN_BLOCKS)
+    fun `several empty lines after package`(@TempDir tempDir: Path) {
+        val folder = tempDir.resolve("src/main/kotlin/com/saveourtool/diktat").also {
+            it.createDirectories()
+        }
+        val testFile = folder.resolve("test.kt").also {
+            it.writeText("""
+                package com.saveourtool.diktat
+                /**
+                 * @param bar
+                 * @return something
+                 */
+                fun foo1(bar: Bar): Baz {
+                    // placeholder
+                }
+            """.trimIndent())
+        }
+        val expectedFile = folder.resolve("expected.kt").also {
+            it.writeText("""
+                package com.saveourtool.diktat
+                /**
+                 * @param bar
+                 * @return something
+                 */
+                fun foo1(bar: Bar): Baz {
+                    // placeholder
+                }
+            """.trimIndent())
+        }
+        fixAndCompare(
+            expectedFile,
+            testFile,
+            overrideRulesConfigList = listOf(
+                RulesConfig(
+                    name = WarningNames.FILE_NO_BLANK_LINE_BETWEEN_BLOCKS,
+                    enabled = true,
+                ),
+                RulesConfig(
+                    name = WarningNames.WRONG_NEWLINES_AROUND_KDOC,
+                    enabled = true,
+                )
+            ),
+        )
+    }
 }

diktat-rules/src/test/kotlin/com/saveourtool/diktat/ruleset/chapter3/spaces/IndentationRuleFixTest.kt

@@ -234,7 +234,7 @@ class IndentationRuleFixTest : FixTestBase("test/paragraph3/indentation",
                                          tempDir: Path
         ): FileComparisonResult {
             val config = IndentationConfig(NEWLINE_AT_END to false).withCustomParameters().asRulesConfigList()
-            return fixAndCompareContent(actualCode, expectedCode, tempDir, config)
+            return fixAndCompareContent(actualCode, expectedCode, tempDir, overrideRulesConfigList = config)
         }
     }
 }

diktat-rules/src/test/kotlin/com/saveourtool/diktat/ruleset/chapter3/spaces/junit/IndentationTestFixExtension.kt

@@ -45,7 +45,8 @@ class IndentationTestFixExtension(
             actualCode,
             expectedCode,
             tempDir,
-            defaultConfig.withCustomParameters(customConfig).asRulesConfigList())
+            overrideRulesConfigList = defaultConfig.withCustomParameters(customConfig).asRulesConfigList(),
+        )
 
         if (!lintResult.isSuccessful) {
             assertThat(lintResult.actualContent)

diktat-rules/src/test/kotlin/com/saveourtool/diktat/util/FixTestBase.kt

@@ -13,6 +13,7 @@
 import org.junit.jupiter.api.Assertions
 import java.nio.file.Path
 import kotlin.io.path.bufferedWriter
+import kotlin.io.path.createDirectories
 import kotlin.io.path.div
 
 /**
@@ -56,19 +57,56 @@
         val testComparatorUnit = testComparatorUnitSupplier(overrideRulesConfigList)
         val result = testComparatorUnit
             .compareFilesFromResources(expectedPath, testPath, overrideResourceReader)
-        if (!result.isSuccessful) {
-            Assertions.assertEquals(
-                result.expectedContentWithoutWarns,
-                result.actualContent,
-            ) {
-                "Content are different"
+        Assertions.assertAll(
+            {
+                Assertions.assertTrue(
+                    result.isSuccessful
+                ) {
+                    "Detected delta: ${result.delta}"
+                }
+            },
+            {
+                Assertions.assertEquals(
+                    result.expectedContentWithoutWarns,
+                    result.actualContent,
+                ) {
+                    "Content are different"
+                }
             }
-        }
-        Assertions.assertTrue(
-            result.isSuccessful
-        ) {
-            "Detected delta: ${result.delta}"
-        }
+        )
+    }
+
+    /**
+     * @param expectedPath path to file with expected result
+     * @param testPath path to file with code that will be transformed by formatter
+     * @param overrideRulesConfigList optional override to [defaultRulesConfigList]
+     * @see fixAndCompareContent
+     */
+    protected fun fixAndCompare(
+        expectedPath: Path,
+        testPath: Path,
+        overrideRulesConfigList: List<RulesConfig>? = null,
+    ) {
+        val testComparatorUnit = testComparatorUnitSupplier(overrideRulesConfigList)
+        val result = testComparatorUnit
+            .compareFilesFromFileSystem(expectedPath, testPath)
+        Assertions.assertAll(
+            {
+                Assertions.assertTrue(
+                    result.isSuccessful
+                ) {
+                    "Detected delta: ${result.delta}"
+                }
+            },
+            {
+                Assertions.assertEquals(
+                    result.expectedContentWithoutWarns,
+                    result.actualContent,
+                ) {
+                    "Content are different"
+                }
+            }
+        )
     }
 
     /**
@@ -89,14 +127,16 @@
         @Language("kotlin") actualContent: String,
         @Language("kotlin") expectedContent: String = actualContent,
         tempDir: Path,
+        subFolder: String? = null,
         overrideRulesConfigList: List<RulesConfig>? = null
     ): FileComparisonResult {
-        val actual = tempDir / "actual.kt"
+        val folder = subFolder?.let { tempDir / it }?.also { it.createDirectories() } ?: tempDir
+        val actual = folder / "actual.kt"
         actual.bufferedWriter().use { out ->
             out.write(actualContent)
         }
 
-        val expected = tempDir / "expected.kt"
+        val expected = folder / "expected.kt"
         expected.bufferedWriter().use { out ->
             out.write(expectedContent)
         }

diktat-ruleset/src/test/kotlin/com/saveourtool/diktat/ruleset/smoke/DiktatSaveSmokeTest.kt

@@ -131,7 +131,7 @@ class DiktatSaveSmokeTest : DiktatSmokeTestBase() {
         private val logger = KotlinLogging.logger {}
         private const val SAVE_VERSION: String = "0.3.4"
         private const val TEMP_DIRECTORY = ".save-cli"
-        private val baseDirectoryPath = tempDir.absolute()
+        private val baseDirectoryPath by lazy { tempDir.absolute() }
 
         private fun getSaveForCurrentOs(): String {
             val osName = System.getProperty("os.name")
@@ -183,20 +183,5 @@ class DiktatSaveSmokeTest : DiktatSmokeTestBase() {
                 diktatFrom?.copyTo(diktat, overwrite = true)
             }
         }
-
-        @AfterAll
-        @JvmStatic
-        internal fun afterAll() {
-            val diktat = baseDirectoryPath / DIKTAT_FAT_JAR
-            val save = baseDirectoryPath / getSaveForCurrentOs()
-            val ktlint = baseDirectoryPath / KTLINT_FAT_JAR
-            val tempDirectory = baseDirectoryPath / TEMP_DIRECTORY
-
-            diktat.deleteIfExistsSilently()
-            ktlint.deleteIfExistsSilently()
-            save.deleteIfExistsSilently()
-
-            tempDirectory.deleteIfExistsRecursively()
-        }
     }
 }

diktat-ruleset/src/test/kotlin/com/saveourtool/diktat/ruleset/smoke/DiktatSmokeTest.kt

@@ -2,6 +2,7 @@ package com.saveourtool.diktat.ruleset.smoke
 
 import com.saveourtool.diktat.api.DiktatError
 import com.saveourtool.diktat.ktlint.format
+import com.saveourtool.diktat.ktlint.lint
 import com.saveourtool.diktat.ruleset.rules.DiktatRuleConfigReaderImpl
 import com.saveourtool.diktat.ruleset.rules.DiktatRuleSetFactoryImpl
 import com.saveourtool.diktat.test.framework.processing.TestComparatorUnit
@@ -31,7 +32,12 @@ class DiktatSmokeTest : DiktatSmokeTestBase() {
             },
             {
                 Assertions.assertEquals(result.expectedContentWithoutWarns, result.actualContent)
-            }
+            },
+//            {
+//                assertUnfixedLintErrors {
+//                    org.assertj.core.api.Assertions.assertThat(unfixedLintErrors).isEmpty()
+//                }
+//            },
         )
 
     }
@@ -48,7 +54,7 @@ class DiktatSmokeTest : DiktatSmokeTestBase() {
     private fun getTestComparatorUnit(config: Path) = TestComparatorUnit(
         resourceReader = { tempDir.resolve("src/main/kotlin").resolve(it).normalize() },
         function = { testFile ->
-            format(
+            lint(
                 ruleSetSupplier = {
                     val diktatRuleConfigReader = DiktatRuleConfigReaderImpl()
                     val diktatRuleSetFactory = DiktatRuleSetFactoryImpl()
@@ -57,6 +63,15 @@ class DiktatSmokeTest : DiktatSmokeTestBase() {
                 file = testFile,
                 cb = { lintError, _ -> unfixedLintErrors.add(lintError) },
             )
+            format(
+                ruleSetSupplier = {
+                    val diktatRuleConfigReader = DiktatRuleConfigReaderImpl()
+                    val diktatRuleSetFactory = DiktatRuleSetFactoryImpl()
+                    diktatRuleSetFactory(diktatRuleConfigReader(config.inputStream()))
+                },
+                file = testFile,
+                cb = { _, _ -> },
+            )
         },
     )
 }