Vorrei vedere i risultati dei test (system.out / err, registrare i messaggi dai componenti che vengono testati) mentre vengono eseguiti nella stessa console che eseguo:

gradle test

E non aspettare fino al completamento dei test per esaminare i report dei test (che vengono generati solo quando i test sono stati completati, quindi non riesco a "mettere in coda" nulla mentre i test sono in esecuzione)

È possibile eseguire Gradle con livello di registrazione INFO nella riga di comando. Ti mostrerà il risultato di ogni test mentre sono in esecuzione. Unico inconveniente è che otterrai molto più output anche per altre attività.

gradle test -i

Ecco la mia versione fantasia:

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

Puoi aggiungere una chiusura Groovy all'interno del tuo file build.gradle che esegue la registrazione per te:

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

Sulla tua console quindi si legge in questo modo:

: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

Dalla versione 1.1 Gradle supporta molte più opzioni per registrare l'output del test . Con queste opzioni a portata di mano è possibile ottenere un output simile con la seguente configurazione:

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

Come ha risposto stefanglase :

l'aggiunta del seguente codice al tuo build.gradle(dalla versione 1.1) funziona bene per l'output su test passati , saltati e falliti .

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

Quello che voglio dire in più (ho scoperto che questo è un problema per i principianti) è che il gradle testcomando esegue il test solo una volta per modifica .

Quindi, se lo stai eseguendo la seconda volta, non ci sarà output sui risultati del test . Puoi anche vedere questo nell'output dell'edificio: gradle quindi dice UP-TO-DATE sui test. Quindi non viene eseguito all'ennesima volta.

Grado intelligente!

Se si desidera forzare l'esecuzione dei casi di test, utilizzare gradle cleanTest test.

Questo è leggermente fuori tema, ma spero che possa aiutare alcuni principianti.

modificare

Come sparc_spread ha affermato nei commenti:

Se si vuole forzare Gradle a nuove prove sempre gestito (che potrebbe non essere sempre una buona idea) è possibile aggiungere outputs.upToDateWhen {false}a testLogging { [...] }. Continua a leggere qui .

Pace.

Disclaimer: sono lo sviluppatore del plug-in Gradle Test Logger.

Puoi semplicemente utilizzare il plug- in Gradle Test Logger per stampare bellissimi registri sulla console. Il plug-in utilizza impostazioni predefinite sensibili per soddisfare la maggior parte degli utenti con poca o nessuna configurazione, ma offre anche una serie di temi e opzioni di configurazione adatti a tutti.

Esempi

Tema standard

Tema moka

uso

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

Assicurati di ottenere sempre l' ultima versione da Gradle Central .

Configurazione

Non hai bisogno di alcuna configurazione. Tuttavia, il plug-in offre alcune opzioni. Questo può essere fatto come segue (mostrati i valori di default):

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
}

Spero che ti piacerà usarlo.

Aggiungi questo per build.gradleimpedire a Gradle di ingoiare stdout e stderr.

test {
    testLogging.showStandardStreams = true
}

È documentato qui .

l'attività 'test' non funziona per il plug-in Android, per il plug-in Android utilizzare quanto segue:

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

Vedere quanto segue: https://stackoverflow.com/a/31665341/3521637

Come seguito alla grande risposta di Shubham, mi piace suggerire di usare i valori enum invece delle stringhe . Dai un'occhiata alla documentazione della classe 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
    }
}

La mia versione minimalista preferita basata sulla risposta di Shubham Chaudhary.

Metti questo nel build.gradlefile:

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

In Gradle utilizzando il plug-in Android:

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

Quindi l'output sarà:

Esecuzione test testConversionMinutes [org.example.app.test.DurationTest] con risultato: SUCCESSO

Unisci la grande risposta di Shubham e JJD usa enum invece di stringa

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 seguito alla risposta di Benjamin Muschko (19 marzo 2011), puoi usare la -ibandiera insieme a grep , per filtrare migliaia di linee indesiderate. Esempi:

Filtro avanzato : visualizza solo il nome e il risultato di ciascuna unità di test e lo stato generale della costruzione. Gli errori di installazione o le eccezioni non vengono visualizzati.

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

Filtro soft : visualizza il nome e il risultato di ogni test unitario, nonché errori / eccezioni di installazione. Ma includerà anche alcune informazioni irrilevanti:

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

Filtro soft, sintassi alternativa: (i token di ricerca sono divisi in singole stringhe)

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

Spiegazione di come funziona: l'output del primo comando ./gradlew test -iviene reindirizzato a un secondo comando grep, che filtrerà molte linee indesiderate in base a un'espressione regolare. "-E"abilita la modalità di espressione regolare e "|"significa "o". È possibile visualizzare il nome e il risultato di un test unitario " > "e lo stato generale è consentito con "BUILD". Nel filtro soft, il "-v"flag significa "non contenente" e "^"significa "inizio della riga". Quindi elimina tutte le righe che iniziano con "In esecuzione" o iniziano con "Creazione", ecc.

Esempio per test unitari di strumentazione Android, con il livello 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:"

Esempio di copertura del test dell'unità Jacoco, con il grado 4.10:

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

Se hai build.gradle.ktsscritto in DSL di Kotlin puoi stampare i risultati dei test con (stavo sviluppando un progetto multipiattaforma kotlin, senza applicare il plugin "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)")
        }
    }))
}

Aggiungi la seguente chiusura al tuo build.gradle. l'output verrà stampato dopo l'esecuzione di ogni test.

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