Ich möchte Testergebnisse sehen (system.out / err, Protokollmeldungen von zu testenden Komponenten), wie sie in derselben Konsole ausgeführt werden, die ich ausführe:

gradle test

Und warten Sie nicht, bis die Tests abgeschlossen sind, um die Testberichte anzuzeigen (die erst generiert werden, wenn die Tests abgeschlossen sind, sodass ich während der Ausführung der Tests nichts "verfolgen" kann).

Sie können Gradle mit der INFO-Protokollierungsstufe in der Befehlszeile ausführen. Es zeigt Ihnen das Ergebnis jedes Tests, während sie ausgeführt werden. Nachteil ist, dass Sie auch für andere Aufgaben viel mehr Output erhalten.

gradle test -i

Hier ist meine schicke Version:

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))
            }
        }
    }
}

Sie können Ihrer build.gradle-Datei einen Groovy-Abschluss hinzufügen, der die Protokollierung für Sie übernimmt:

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

Auf Ihrer Konsole lautet es dann wie folgt:

: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

Seit Version 1.1 unterstützt Gradle viel mehr Optionen zum Protokollieren der Testausgabe . Mit diesen Optionen können Sie eine ähnliche Ausgabe mit der folgenden Konfiguration erzielen:

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

Als stefanglase antwortete:

Das Hinzufügen des folgenden Codes zu Ihrem build.gradle(seit Version 1.1) funktioniert einwandfrei für die Ausgabe bei bestandenen , übersprungenen und fehlgeschlagenen Tests.

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

Was ich zusätzlich sagen möchte (ich habe herausgefunden, dass dies für den Anfang ein Problem ist), ist, dass der gradle testBefehl den Test nur einmal pro Änderung ausführt .

Wenn Sie es also das zweite Mal ausführen, werden die Testergebnisse nicht ausgegeben . Sie können dies auch in der Gebäudeausgabe sehen: gradle sagt dann bei Tests UP-TO-DATE . Es wird also nicht zum n-ten Mal ausgeführt.

Smart Gradle!

Wenn Sie die Ausführung der Testfälle erzwingen möchten, verwenden Sie gradle cleanTest test.

Dies ist etwas abseits des Themas, aber ich hoffe, es wird einigen Neulingen helfen.

bearbeiten

Wie in den Kommentaren angegeben, sparc_spread :

Wenn Sie gradle erzwingen wollen immer laufen neue Prüfungen (die immer vielleicht keine gute Idee sein) können Sie hinzufügen outputs.upToDateWhen {false}zu testLogging { [...] }. Lesen Sie hier weiter .

Frieden.

Haftungsausschluss: Ich bin der Entwickler des Gradle Test Logger Plugins.

Sie können einfach das Gradle Test Logger Plugin verwenden , um schöne Protokolle auf der Konsole zu drucken. Das Plugin verwendet sinnvolle Standardeinstellungen, um die meisten Benutzer mit wenig oder keiner Konfiguration zufrieden zu stellen, bietet aber auch eine Reihe von Themen und Konfigurationsoptionen für jeden Geschmack.

Beispiele

Standardthema

Mokka-Thema

Verwendung

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

Stellen Sie sicher, dass Sie immer die neueste Version von Gradle Central erhalten .

Aufbau

Sie benötigen überhaupt keine Konfiguration. Das Plugin bietet jedoch einige Optionen. Dies kann wie folgt erfolgen (Standardwerte werden angezeigt):

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
}

Ich hoffe, Sie werden es genießen, es zu benutzen.

Fügen Sie dies hinzu, um build.gradlezu verhindern, dass Gradle stdout und stderr verschluckt.

test {
    testLogging.showStandardStreams = true
}

Es ist hier dokumentiert .

Die 'Test'-Aufgabe funktioniert nicht für das Android-Plugin. Verwenden Sie für das Android-Plugin Folgendes:

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

Siehe folgendes: https://stackoverflow.com/a/31665341/3521637

Als Folge von Shubhams großartiger Antwort möchte ich vorschlagen, Enum- Werte anstelle von Zeichenfolgen zu verwenden . Bitte schauen Sie sich die Dokumentation der TestLogging-Klasse an .

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
    }
}

Meine minimalistische Lieblingsversion basiert auf der Antwort von Shubham Chaudhary.

Legen Sie dies in die build.gradleDatei:

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

In Gradle mit Android-Plugin:

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

Dann wird die Ausgabe sein:

Ausführen von test testConversionMinutes [org.example.app.test.DurationTest] mit Ergebnis: SUCCESS

Merge von Shubhams großartiger Antwort und JJD verwenden Enum anstelle von String

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))
           }
       }
   }
}

In Anlehnung an die Antwort von Benjamin Muschko (19. März 2011) können Sie die -iFlagge zusammen mit grep verwenden , um Tausende unerwünschter Zeilen herauszufiltern. Beispiele:

Starker Filter - Zeigt nur den Namen und das Ergebnis jedes Komponententests sowie den gesamten Build-Status an. Setup-Fehler oder Ausnahmen werden nicht angezeigt.

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

Weicher Filter - Zeigt den Namen und das Ergebnis jedes Komponententests sowie Setup-Fehler / Ausnahmen an. Es wird aber auch einige irrelevante Informationen enthalten:

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

Weicher Filter, alternative Syntax: (Suchtoken werden in einzelne Zeichenfolgen aufgeteilt)

./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:"

Erläuterung der Funktionsweise: Die Ausgabe des ersten Befehls ./gradlew test -iwird an einen zweiten Befehl weitergeleitet grep, der viele unerwünschte Zeilen basierend auf einem regulären Ausdruck herausfiltert. "-E"aktiviert den regulären Ausdrucksmodus und "|"bedeutet "oder". Ein Komponententestname und ein Ergebnis dürfen mit angezeigt werden " > ", und der Gesamtstatus ist mit zulässig "BUILD". Im "-v"Softfilter bedeutet das Flag "nicht enthalten" und "^""Zeilenanfang". Es werden also alle Zeilen entfernt, die mit "Ausführen" oder "Erstellen" usw. beginnen.

Beispiel für Android Instrumentation Unit Tests mit 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:"

Beispiel für die Jacoco-Unit-Test-Abdeckung mit Gradle 4.10:

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

Wenn Sie ein build.gradle.ktsin Kotlin DSL geschriebenes haben , können Sie Testergebnisse mit drucken (ich habe ein kotlin Multi-Plattform-Projekt entwickelt, ohne dass ein "Java" -Plugin angewendet wurde):

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)")
        }
    }))
}