tests_codecov.gradle

ext {
    readmeFormat = false // pass -DreadmeFormat to format benchmark results to update readme
    kotestVersion = '4.1.0.RC2'
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter:5.6.2'
    testApi 'com.jayway.jsonpath:json-path:2.4.0'
    testImplementation "org.json:json:20180813"
    testImplementation "io.kotest:kotest-runner-junit5-jvm:$kotestVersion" // for kotest framework
    testImplementation "io.kotest:kotest-assertions-core-jvm:$kotestVersion" // for kotest core jvm assertions
}

compileTestKotlin {
    kotlinOptions.jvmTarget = "1.8"
}

task benchmark(type: Test) {
    // enable junit 5
    useJUnitPlatform()

    doFirst {
        if (!System.getProperty("readmeFormat", "false").equals("false")) {
            readmeFormat = true
        }

        if (readmeFormat) {
            jvmArgs '-DreadmeFormat=true'
            readmeFormat = false
        }
        filter {
            include("com/nfeld/jsonpathkt/BenchmarkTest.class")
        }
        testLogging {
            showStandardStreams = true
        }
    }

    // Make this task never up to date, thus forcing rerun of all tests whenever task is run
    outputs.upToDateWhen { false }
}

task perfTest(type: Test) {
    // enable junit 5
    useJUnitPlatform()

    doFirst {
        filter {
            include("com/nfeld/jsonpathkt/PerfTest.class")
        }
        testLogging {
            // show test results for following events
            events 'PASSED', 'FAILED', 'SKIPPED'

            // show printlines
            showStandardStreams = true
        }
    }

    // Make this task never up to date, thus forcing rerun of all tests whenever task is run
    outputs.upToDateWhen { false }
}

test {
    // enable junit 5
    useJUnitPlatform()

    doFirst {
        filter {
            includeTestsMatching("com.nfeld.jsonpathkt.*")
            exclude(
                    "com/nfeld/jsonpathkt/BenchmarkTest.class",
                    "com/nfeld/jsonpathkt/PerfTest.class"
            )
        }

        testLogging {
            // show test results for following events
            events 'PASSED', 'FAILED', 'SKIPPED'

            // show printlines
            showStandardStreams = true
        }

        // show test summary at end
        afterSuite { desc, result ->
            if (!desc.parent) {
                println "\nTest result: ${result.resultType}"
                println "Test summary: ${result.testCount} tests, " +
                        "${result.successfulTestCount} succeeded, " +
                        "${result.failedTestCount} failed, " +
                        "${result.skippedTestCount} skipped"
            }
        }
    }

    // Make this task never up to date, thus forcing rerun of all tests whenever task is run
    outputs.upToDateWhen { false }

    // code coverage
    jacoco {
        append = false
        destinationFile = file("$buildDir/jacoco/junitPlatformTest.exec")
        includeNoLocationClasses = true
    }

    finalizedBy jacocoTestReport
}

jacoco {
    toolVersion = "0.8.5"
    reportsDir = file("$buildDir/reports")
}

jacocoTestReport {
    group = "Reporting"
    description = "Generate Jacoco coverage report."
    classDirectories = fileTree(
            dir: "$buildDir/classes/kotlin/main"
    )
    def coverageSourceDirs = [
            "src/main/kotlin"
    ]
    additionalSourceDirs = files(coverageSourceDirs)
    sourceDirectories = files(coverageSourceDirs)
    executionData = files("$buildDir/jacoco/junitPlatformTest.exec")
    reports {
        xml.enabled = true
        html.enabled = true
        csv.enabled = false
    }

    afterEvaluate {
        classDirectories = files(classDirectories.files.collect {
            // Exclude simple LinkedHashMap subclass from report
            fileTree(dir: it, excludes: [
                    '**/LRUCache$LRUMap*',
                    '**/JsonNodeKt*'
            ])
        })
    }
}

check.dependsOn jacocoTestCoverageVerification

jacocoTestCoverageVerification {
    violationRules {
        rule {
            // element = 'CLASS'
            limit {
                counter = 'LINE'
                value = 'COVEREDRATIO'
                minimum = 0.90
            }
        }
    }
}