Added instrumentation filtering by common filters

Fixes #201

README.md

@@ -224,6 +224,8 @@ Examples `my.package.ClassName` or `my.*.*Name` are allowed, while `my/package/C
 
 Exclusion rules have priority over inclusion ones.
 
+Exclusion and inclusion rules from the [test task](#configuring-jvm-test-task) (if at least one of them is not empty) take precedence over rules from the [common class filter](#configuring-project).
+
 ### Configuring project
 In the project in which the plugin is applied, you can configure instrumentation and default Kover tasks:
 

src/functionalTest/kotlin/kotlinx/kover/test/functional/cases/AdaptersTests.kt

@@ -1,6 +1,5 @@
 package kotlinx.kover.test.functional.cases
 
-import kotlinx.kover.test.functional.cases.utils.assertFullyCovered
 import kotlinx.kover.test.functional.cases.utils.defaultXmlReport
 import kotlinx.kover.test.functional.cases.utils.defaultMergedXmlReport
 import kotlinx.kover.test.functional.core.BaseGradleScriptTest

src/functionalTest/kotlin/kotlinx/kover/test/functional/cases/InstrumentationFilteringTests.kt

@@ -23,7 +23,6 @@ internal class InstrumentationFilteringTests : BaseGradleScriptTest() {
                 classCounter("org.jetbrains.SecondClass").assertCovered()
             }
         }
-
     }
 
     @Test
@@ -45,6 +44,65 @@ internal class InstrumentationFilteringTests : BaseGradleScriptTest() {
             }
         }
     }
+    @Test
+    fun testExcludeByKoverExtension() {
+        val build = diverseBuild(ALL_LANGUAGES, ALL_ENGINES, ALL_TYPES)
+        build.addKoverRootProject {
+            sourcesFrom("simple")
+            kover {
+                filters {
+                    classes {
+                        excludes += "org.jetbrains.*Exa?ple*"
+                    }
+                }
+                xmlReport {
+                    overrideFilters {
+                        classes {
+                            // override class filter (discard all rules) to in order for all classes to be included in the report
+                        }
+                    }
+                }
+            }
+        }
+        val runner = build.prepare()
+        runner.run("build", "koverXmlReport") {
+            xml(defaultXmlReport()) {
+                classCounter("org.jetbrains.ExampleClass").assertFullyMissed()
+                classCounter("org.jetbrains.SecondClass").assertCovered()
+            }
+        }
+    }
+
+    @Test
+    fun testExcludeIncludeByKoverExtension() {
+        val build = diverseBuild(ALL_LANGUAGES, ALL_ENGINES, ALL_TYPES)
+        build.addKoverRootProject {
+            sourcesFrom("simple")
+            kover {
+                filters {
+                    classes {
+                        includes += "org.jetbrains.*Cla?s"
+                        excludes += "org.jetbrains.*Exa?ple*"
+                    }
+                }
+                xmlReport {
+                    overrideFilters {
+                        classes {
+                            // override class filter (discard all rules) to in order for all classes to be included in the report
+                        }
+                    }
+                }
+            }
+        }
+        val runner = build.prepare()
+        runner.run("build", "koverXmlReport") {
+            xml(defaultXmlReport()) {
+                classCounter("org.jetbrains.ExampleClass").assertFullyMissed()
+                classCounter("org.jetbrains.Unused").assertFullyMissed()
+                classCounter("org.jetbrains.SecondClass").assertCovered()
+            }
+        }
+    }
 
     @Test
     fun testDisableInstrumentationOfTask() {

src/functionalTest/kotlin/kotlinx/kover/test/functional/cases/MultiProjectTests.kt

@@ -71,36 +71,6 @@ internal class MultiProjectTests : BaseGradleScriptTest() {
             }
         }
     }
-//
-//    @Test
-//    fun testLinkedProjectsReports() {
-//        builder("Testing the generation of project reports with running all tests for all projects")
-//            .types(ProjectType.KOTLIN_JVM, ProjectType.KOTLIN_MULTIPLATFORM)
-//            .engines(CoverageEngineVendor.INTELLIJ, CoverageEngineVendor.JACOCO)
-//            .configKover { runAllTestsForProjectTask = true }
-//            .sources("multiproject-user")
-//            .subproject(subprojectName) {
-//                sources("multiproject-common")
-//            }
-//            .build()
-//            .run("koverReport") {
-//                xml(defaultXmlReport()) {
-//                    classCounter("org.jetbrains.CommonClass").assertAbsent()
-//                    classCounter("org.jetbrains.CommonInternalClass").assertAbsent()
-//                    classCounter("org.jetbrains.UserClass").assertFullyCovered()
-//                }
-//
-//                subproject(subprojectName) {
-//                    xml(defaultXmlReport()) {
-//                        classCounter("org.jetbrains.UserClass").assertAbsent()
-//
-//                        // common class fully covered because calls from the root project are counted too
-//                        classCounter("org.jetbrains.CommonClass").assertFullyCovered()
-//                        classCounter("org.jetbrains.CommonInternalClass").assertFullyCovered()
-//                    }
-//                }
-//            }
-//    }
 
     @Test
     fun testDisabledKover() {

src/functionalTest/kotlin/kotlinx/kover/test/functional/cases/utils/Commons.kt

@@ -4,22 +4,18 @@
 
 package kotlinx.kover.test.functional.cases.utils
 
-import kotlinx.kover.api.*
-import kotlinx.kover.test.functional.core.*
 import kotlinx.kover.test.functional.core.RunResult
 import org.gradle.testkit.runner.*
 import kotlin.test.*
 
 internal fun RunResult.checkDefaultBinaryReport(mustExist: Boolean = true) {
-    val binary: String = defaultBinaryReport(engine, projectType)
-
     if (mustExist) {
-        file(binary) {
+        file(defaultBinaryReport) {
             assertTrue { exists() }
             assertTrue { length() > 0 }
         }
     } else {
-        file(binary) {
+        file(defaultBinaryReport) {
             assertFalse { exists() }
         }
     }
@@ -58,49 +54,3 @@ internal fun RunResult.checkReports(xmlPath: String, htmlPath: String, mustExist
         }
     }
 }
-
-internal fun RunResult.checkIntellijErrors(errorExpected: Boolean = false) {
-    if (engine != CoverageEngineVendor.INTELLIJ) return
-
-    file(errorsDirectory()) {
-        if (this.exists() && !errorExpected) {
-            val errorLogs = this.listFiles()?.map { it.name } ?: emptyList()
-            throw AssertionError("Detected IntelliJ Coverage Engine errors: $errorLogs")
-        }
-    }
-}
-
-internal fun Counter?.assertAbsent() {
-    assertNull(this)
-}
-
-internal fun Counter?.assertFullyMissed() {
-    assertNotNull(this)
-    assertTrue { this.missed > 0 }
-    assertEquals(0, this.covered)
-}
-
-internal fun Counter?.assertCovered() {
-    assertNotNull(this)
-    assertTrue { this.covered > 0 }
-}
-
-
-internal fun Counter?.assertTotal(count: Int) {
-    assertNotNull(this)
-    assertEquals(count, covered + missed)
-}
-
-internal fun Counter?.assertCovered(covered: Int, missed: Int) {
-    assertNotNull(this)
-    assertEquals(covered, this.covered)
-    assertEquals(missed, this.missed)
-}
-
-internal fun Counter?.assertFullyCovered() {
-    assertNotNull(this)
-    assertTrue { this.covered > 0 }
-    assertEquals(0, this.missed)
-}
-
-

src/functionalTest/kotlin/kotlinx/kover/test/functional/cases/utils/Defaults.kt

@@ -4,27 +4,23 @@
 
 package kotlinx.kover.test.functional.cases.utils
 
-import kotlinx.kover.api.*
 import kotlinx.kover.test.functional.core.ProjectType
 
 
-internal fun defaultTestTask(engine: CoverageEngineVendor, projectType: ProjectType): String {
-    val extension = if (engine == CoverageEngineVendor.INTELLIJ) "ic" else "exec"
+internal fun defaultTestTask(projectType: ProjectType): String {
     return when (projectType) {
-        ProjectType.KOTLIN_JVM -> "test.$extension"
-        ProjectType.KOTLIN_MULTIPLATFORM -> "jvmTest.$extension"
-        ProjectType.ANDROID -> "jvmTest.$extension"
+        ProjectType.KOTLIN_JVM -> "test"
+        ProjectType.KOTLIN_MULTIPLATFORM -> "jvmTest"
+        ProjectType.ANDROID -> "jvmTest"
     }
 }
 
-internal fun defaultBinaryReport(engine: CoverageEngineVendor, projectType: ProjectType): String {
-    return "kover/" + defaultTestTask(engine, projectType)
-}
-
 internal fun defaultMergedXmlReport() = "reports/kover/merged/xml/report.xml"
 internal fun defaultMergedHtmlReport() = "reports/kover/merged/html"
 
 internal fun defaultXmlReport() = "reports/kover/xml/report.xml"
 internal fun defaultHtmlReport() = "reports/kover/html"
 
 internal fun errorsDirectory() = "kover/errors"
+
+internal fun binaryReportsDirectory() = "kover"