Gradle：如何在控制台实时显示测试结果？

Question

我希望看到测试结果（system.out/err，来自正在测试的组件的日志消息）当它们在我运行的同一个控制台中运行时：

gradle test

而不是等到测试完成才查看测试报告（仅在测试完成时生成，因此在测试运行时我无法“tail -f”任何内容）

Answer 1

这是我喜欢的版本：

import org.gradle.api.tasks.testing.logging.TestExceptionFormat
import org.gradle.api.tasks.testing.logging.TestLogEvent

tasks.withType(Test) {
    testLogging {
        // set options for log level LIFECYCLE
        events TestLogEvent.FAILED,
               TestLogEvent.PASSED,
               TestLogEvent.SKIPPED,
               TestLogEvent.STANDARD_OUT
        exceptionFormat TestExceptionFormat.FULL
        showExceptions true
        showCauses true
        showStackTraces true

        // set options for log level DEBUG and INFO
        debug {
            events TestLogEvent.STARTED,
                   TestLogEvent.FAILED,
                   TestLogEvent.PASSED,
                   TestLogEvent.SKIPPED,
                   TestLogEvent.STANDARD_ERROR,
                   TestLogEvent.STANDARD_OUT
            exceptionFormat TestExceptionFormat.FULL
        }
        info.events = debug.events
        info.exceptionFormat = debug.exceptionFormat

        afterSuite { desc, result ->
            if (!desc.parent) { // will match the outermost suite
                def output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} passed, ${result.failedTestCount} failed, ${result.skippedTestCount} skipped)"
                def startItem = '|  ', endItem = '  |'
                def repeatLength = startItem.length() + output.length() + endItem.length()
                println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength))
            }
        }
    }
}

Answer 2

您可以在命令行上以 INFO 日志记录级别运行 Gradle。它将在运行时向您显示每个测试的结果。缺点是你也会为其他任务获得更多的输出。

gradle test -i

Answer 3

免责声明：我是 Gradle Test Logger 插件的开发者。

您只需使用 Gradle 测试记录器插件 在控制台上打印漂亮的日志。该插件使用合理的默认设置来满足大多数用户的需求，只需很少的配置或无需配置，但还提供了许多主题和配置选项来适合每个人。

示例

标准主题

Mocha 主题

用法

plugins {
    id 'com.adarshr.test-logger' version '<version>'
}

确保您始终从 Gradle Central 获取最新版本。

配置

您根本不需要任何配置。但是，该插件提供了一些选项。这可以按如下方式完成（显示默认值）：

testlogger {
    // pick a theme - mocha, standard, plain, mocha-parallel, standard-parallel or plain-parallel
    theme 'standard'

    // set to false to disable detailed failure logs
    showExceptions true

    // set to false to hide stack traces
    showStackTraces true

    // set to true to remove any filtering applied to stack traces
    showFullStackTraces false

    // set to false to hide exception causes
    showCauses true

    // set threshold in milliseconds to highlight slow tests
    slowThreshold 2000

    // displays a breakdown of passes, failures and skips along with total duration
    showSummary true

    // set to true to see simple class names
    showSimpleNames false

    // set to false to hide passed tests
    showPassed true

    // set to false to hide skipped tests
    showSkipped true

    // set to false to hide failed tests
    showFailed true

    // enable to see standard out and error streams inline with the test results
    showStandardStreams false

    // set to false to hide passed standard out and error streams
    showPassedStandardStreams true

    // set to false to hide skipped standard out and error streams
    showSkippedStandardStreams true

    // set to false to hide failed standard out and error streams
    showFailedStandardStreams true
}

我希望您会喜欢使用它。

Answer 4

您可以在 build.gradle 文件中添加一个 Groovy 闭包来为您进行日志记录：

test {
    afterTest { desc, result -> 
        logger.quiet "Executing test ${desc.name} [${desc.className}] with result: ${result.resultType}"
    }
}

在您的控制台上，它的内容如下所示：

:compileJava UP-TO-DATE
:compileGroovy
:processResources
:classes
:jar
:assemble
:compileTestJava
:compileTestGroovy
:processTestResources
:testClasses
:test
Executing test maturesShouldBeCharged11DollarsForDefaultMovie [movietickets.MovieTicketsTests] with result: SUCCESS
Executing test studentsShouldBeCharged8DollarsForDefaultMovie [movietickets.MovieTicketsTests] with result: SUCCESS
Executing test seniorsShouldBeCharged6DollarsForDefaultMovie [movietickets.MovieTicketsTests] with result: SUCCESS
Executing test childrenShouldBeCharged5DollarsAnd50CentForDefaultMovie [movietickets.MovieTicketsTests] with result: SUCCESS
:check
:build

自版本 1.1 Gradle 支持很多 记录测试输出的更多选项。有了这些选项，您可以通过以下配置实现类似的输出：

test {
    testLogging {
        events "passed", "skipped", "failed"
    }
}

Answer 5

正如 stefanglase 回答的那样：

将以下代码添加到您的 build.gradle （自版本 1.1 起）对于通过、跳过的输出效果很好和失败测试。

test {
    testLogging {
        events "passed", "skipped", "failed", "standardOut", "standardError"
    }
}

我想说的另外一点（我发现这对于初学者来说是一个问题）是 gradle test 命令每次更改仅执行一次测试。

因此，如果您第二次运行它，则测试结果将不会有输出。您还可以在构建输出中看到这一点：gradle 然后在测试中显示 UP-TO-DATE。所以它没有执行第n次。

智能分级！

如果您想强制运行测试用例，请使用gradle cleanTest test。

这有点偏离主题，但我希望它能对一些新手有所帮助。

编辑

正如sparc_spread在评论中所述：

如果你想强制gradle始终运行新的测试（这可能并不总是一个好主意）您可以将 outputs.upToDateWhen {false} 添加到 testLogging { [...] }。继续阅读此处。

和平。

Answer 6

将其添加到 build.gradle 以阻止 gradle 吞噬 stdout 和 stderr。

test {
    testLogging.showStandardStreams = true
}

它已记录此处。

Answer 7

“测试”任务不适用于 Android 插件，对于 Android 插件，请使用以下内容：

// Test Logging
tasks.withType(Test) {
    testLogging {
        events "started", "passed", "skipped", "failed"
    }
}

请参阅以下内容：https://stackoverflow.com/ a/31665341/3521637

Answer 8

作为 Shubham 的精彩答案的后续，我建议使用 enum 值而不是 字符串。请查看文档TestLogging 类。

import org.gradle.api.tasks.testing.logging.TestExceptionFormat
import org.gradle.api.tasks.testing.logging.TestLogEvent

tasks.withType(Test) {
    testLogging {
        events TestLogEvent.FAILED,
               TestLogEvent.PASSED,
               TestLogEvent.SKIPPED,
               TestLogEvent.STANDARD_ERROR,
               TestLogEvent.STANDARD_OUT
        exceptionFormat TestExceptionFormat.FULL
        showCauses true
        showExceptions true
        showStackTraces true
    }
}

Answer 9

我最喜欢的简约版本基于 Shubham Chaudhary 的回答。

将其放入 build.gradle 文件中：

test {
    afterSuite { desc, result ->
    if (!desc.parent)
        println("${result.resultType} " +
            "(${result.testCount} tests, " +
            "${result.successfulTestCount} successes, " +
            "${result.failedTestCount} failures, " +
            "${result.skippedTestCount} skipped)")
    }
}

Answer 10

在 Gradle 中使用 Android 插件：

gradle.projectsEvaluated {
    tasks.withType(Test) { task ->
        task.afterTest { desc, result ->
            println "Executing test ${desc.name} [${desc.className}] with result: ${result.resultType}"
        }
    }
}

那么输出将是：

执行测试 testConversionMinutes [org.example.app.test.DurationTest]，结果：成功

Answer 11

如果您有一个用 Kotlin DSL 编写的 build.gradle.kts ，您可以使用打印测试结果（我正在开发一个 kotlin 多平台项目，没有“java”插件应用）：

tasks.withType<AbstractTestTask> {
    afterSuite(KotlinClosure2({ desc: TestDescriptor, result: TestResult ->
        if (desc.parent == null) { // will match the outermost suite
            println("Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)")
        }
    }))
}

Answer 12

对于 Android，这效果很好：

android {
...

testOptions {
    unitTests.all {
        testLogging {
            outputs.upToDateWhen { false }
            events "passed", "failed", "skipped", "standardError"
            showCauses true
            showExceptions true
        }
    }
} 

}

请参阅 运行 Android 单元/ 从控制台进行仪器测试

Answer 13

只需将以下闭包添加到您的 build.gradle 中即可。每次测试执行后都会打印输出。

test{
    useJUnitPlatform()
    afterTest { desc, result ->
        def output = "Class name: ${desc.className}, Test name: ${desc.name},  (Test status: ${result.resultType})"
        println( '\n' + output)
    }
}

Answer 14

合并 Shubham 的精彩答案 和 JJD使用枚举代替字符串

tasks.withType(Test) {
   testLogging {
       // set options for log level LIFECYCLE
       events TestLogEvent.PASSED,
            TestLogEvent.SKIPPED, TestLogEvent.FAILED, TestLogEvent.STANDARD_OUT
       showExceptions true
       exceptionFormat TestExceptionFormat.FULL
       showCauses true
       showStackTraces true

    // set options for log level DEBUG and INFO
       debug {
        events TestLogEvent.STARTED, TestLogEvent.PASSED, TestLogEvent.SKIPPED, TestLogEvent.FAILED, TestLogEvent.STANDARD_OUT, TestLogEvent.STANDARD_ERROR
        exceptionFormat TestExceptionFormat.FULL
       }
       info.events = debug.events
       info.exceptionFormat = debug.exceptionFormat

       afterSuite { desc, result ->
           if (!desc.parent) { // will match the outermost suite
               def output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} successes, ${result.failedTestCount} failures, ${result.skippedTestCount} skipped)"
               def startItem = '|  ', endItem = '  |'
               def repeatLength = startItem.length() + output.length() + endItem.length()
               println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength))
           }
       }
   }
}

Answer 15

对于使用 Kotlin DSL 的用户，您可以执行以下操作：

tasks {
  named<Test>("test") {
    testLogging.showStandardStreams = true
  }
}

Answer 16

继 Benjamin Muschko 的回答（2011 年 3 月 19 日），您可以将 -i 标志与 grep，过滤掉数千个不需要的行。示例：

强过滤器 - 仅显示每个单元测试名称和测试结果以及整体构建状态。不显示设置错误或异常。

./gradlew test -i | grep -E " > |BUILD"

---

软过滤器 - 显示每个单元测试名称和测试结果，以及设置错误/异常。但它也会包含一些不相关的信息：

./gradlew test -i | grep -E -v "^Executing |^Creating |^Parsing |^Using |^Merging |^Download |^title=Compiling|^AAPT|^future=|^task=|:app:|V/InstrumentationResultParser:"

软过滤器，替代语法：（搜索标记被分割成单独的字符串）

./gradlew test -i | grep -v -e "^Executing " -e "^Creating " -e "^Parsing " -e "^Using " -e "^Merging " -e "^Download " -e "^title=Compiling" -e "^AAPT" -e "^future=" -e "^task=" -e ":app:" -e "V/InstrumentationResultParser:"

---

它如何工作的说明：

第一个命令是./gradlew test -i 和 "-i" 表示“Info/Verbose”模式，实时打印每次测试的结果，但也会显示大量不需要的内容调试线。

因此，第一个命令 ./gradlew test -i 的输出通过管道传输到第二个命令 grep，该命令将根据正则表达式过滤掉许多不需要的行。 "-E" 启用单个字符串的正则表达式模式； "-e" 启用多个字符串的正则表达式；正则表达式字符串中的 "|" 表示“或”。

在强过滤器中，允许使用" > "显示单元测试名称和测试结果，并允许使用"BUILD"显示整体状态。

在软过滤器中，“-v”标志表示“不包含” " 和 "^" 表示“行的开头”。因此，它会删除所有以“Executing”或“Creating”开头的行，等等。

---

Android 仪器单元测试示例，使用 gradle 5.1：

./gradlew connectedDebugAndroidTest --continue -i | grep -v -e \
    "^Transforming " -e "^Skipping " -e "^Cache " -e "^Performance " -e "^Creating " -e \
    "^Parsing " -e "^file " -e "ddms: " -e ":app:" -e "V/InstrumentationResultParser:"

Jacoco 单元测试覆盖率示例，使用等级 4.10：

./gradlew createDebugCoverageReport --continue -i | grep -E -v "^Executing |^Creating |^Parsing |^Using |^Merging |^Download |^title=Compiling|^AAPT|^future=|^task=|:app:|V/InstrumentationResultParser:"

Answer 17

如果您使用的是木星并且所有答案都不起作用，请考虑验证其设置是否正确：

test {
    useJUnitPlatform()
    outputs.upToDateWhen { false }
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.0'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.7.0'
}

然后尝试接受的答案

Answer 18

对于那些使用 Kotlin DSL 的人来说，更全面的回应：

subprojects {
    // all the other stuff
    // ...
    tasks.named<Test>("test") {
        useJUnitPlatform()
        setupTestLogging()
    }
}

fun Test.setupTestLogging() {
    testLogging {
        events(
            org.gradle.api.tasks.testing.logging.TestLogEvent.FAILED,
            org.gradle.api.tasks.testing.logging.TestLogEvent.PASSED,
            org.gradle.api.tasks.testing.logging.TestLogEvent.SKIPPED,
            org.gradle.api.tasks.testing.logging.TestLogEvent.STANDARD_OUT,
        )
        exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
        showExceptions = true
        showCauses = true
        showStackTraces = true

        addTestListener(object : TestListener {
            override fun beforeSuite(suite: TestDescriptor) {}
            override fun beforeTest(testDescriptor: TestDescriptor) {}
            override fun afterTest(testDescriptor: TestDescriptor, result: TestResult) {}
            override fun afterSuite(suite: TestDescriptor, result: TestResult) {
                if (suite.parent != null) { // will match the outermost suite
                    val output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} passed, ${result.failedTestCount} failed, ${result.skippedTestCount} skipped)"
                    val startItem = "|  "
                    val endItem = "  |"
                    val repeatLength = startItem.length + output.length + endItem.length
                    val messages = """
                        ${(1..repeatLength).joinToString("") { "-" }}
                        $startItem$output$endItem
                        ${(1..repeatLength).joinToString("") { "-" }}
                    """.trimIndent()
                    println(messages)
                }
            }
        })
    }
}

这应该会产生接近 @odemolliens 答案的输出。

Answer 19

我为 Kotlin DSL 编写了一个测试记录器。您可以将此块放在项目范围 build.gradle.kts 文件中。

subprojects {
    tasks.withType(Test::class.java) {
        testLogging {
            showCauses = false
            showExceptions = false
            showStackTraces = false
            showStandardStreams = false

            val ansiReset = "\u001B[0m"
            val ansiGreen = "\u001B[32m"
            val ansiRed = "\u001B[31m"
            val ansiYellow = "\u001B[33m"

            fun getColoredResultType(resultType: ResultType): String {
                return when (resultType) {
                    ResultType.SUCCESS -> "$ansiGreen $resultType $ansiReset"
                    ResultType.FAILURE -> "$ansiRed $resultType $ansiReset"
                    ResultType.SKIPPED -> "$ansiYellow $resultType $ansiReset"
                }
            }

            afterTest(
                KotlinClosure2({ desc: TestDescriptor, result: TestResult ->
                    println("${desc.className} | ${desc.displayName} = ${getColoredResultType(result.resultType)}")
                })
            )

            afterSuite(
                KotlinClosure2({ desc: TestDescriptor, result: TestResult ->
                    if (desc.parent == null) {
                        println("Result: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} passed, ${result.failedTestCount} failed, ${result.skippedTestCount} skipped)")
                    }
                })
            )
        }
    }
}