Je voudrais voir les résultats des tests (system.out / err, journaux des composants testés) lorsqu'ils s'exécutent dans la même console que j'exécute:

gradle test

Et n'attendez pas que les tests soient terminés pour consulter les rapports de test (qui ne sont générés que lorsque les tests sont terminés, donc je ne peux rien "tail -f" pendant que les tests sont en cours)

Vous pouvez exécuter Gradle avec le niveau de journalisation INFO sur la ligne de commande. Il vous montrera le résultat de chaque test pendant leur exécution. L'inconvénient est que vous obtiendrez également beaucoup plus de sortie pour d'autres tâches.

gradle test -i

Voici ma version fantaisie:

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

Vous pouvez ajouter une fermeture Groovy dans votre fichier build.gradle qui effectue la journalisation pour vous:

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

Sur votre console, il se lit alors comme suit:

: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

Depuis la version 1.1, Gradle prend en charge beaucoup plus d'options pour enregistrer la sortie de test . Avec ces options à portée de main, vous pouvez obtenir une sortie similaire avec la configuration suivante:

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

Comme l'a répondu stefanglase :

l'ajout du code suivant à votre build.gradle(depuis la version 1.1) fonctionne bien pour la sortie des tests réussis , ignorés et échoués .

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

Ce que je veux dire en plus (j'ai découvert que c'est un problème pour les démarreurs), c'est que la gradle testcommande n'exécute le test qu'une seule fois par changement .

Donc, si vous l'exécutez la deuxième fois, il n'y aura pas de sortie sur les résultats des tests . Vous pouvez également le voir dans la sortie du bâtiment: gradle indique ensuite UP-TO-DATE lors des tests. Donc, ce n'est pas exécuté une énième fois.

Gradle intelligent!

Si vous souhaitez forcer l'exécution des scénarios de test, utilisez gradle cleanTest test.

Ceci est légèrement hors sujet mais j'espère que cela aidera certains débutants.

Éditer

Comme l'a indiqué sparc_spread dans les commentaires:

Si vous voulez forcer gradle à de nouveaux essais toujours courir ( ce qui pourrait être pas toujours une bonne idée) que vous pouvez ajouter outputs.upToDateWhen {false}à testLogging { [...] }. Continuez à lire ici .

Paix.

Avertissement: je suis le développeur du plug-in Gradle Test Logger.

Vous pouvez simplement utiliser le plug-in Gradle Test Logger pour imprimer de beaux journaux sur la console. Le plugin utilise des valeurs par défaut raisonnables pour satisfaire la plupart des utilisateurs avec peu ou pas de configuration, mais offre également un certain nombre de thèmes et d'options de configuration pour convenir à tout le monde.

Exemples

Thème standard

Thème moka

Usage

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

Assurez-vous de toujours obtenir la dernière version de Gradle Central .

Configuration

Vous n'avez besoin d'aucune configuration. Cependant, le plugin propose quelques options. Cela peut être fait comme suit (valeurs par défaut affichées):

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
}

J'espère que vous apprécierez de l'utiliser.

Ajoutez ceci pour build.gradleempêcher Gradle d'avaler stdout et stderr.

test {
    testLogging.showStandardStreams = true
}

C'est documenté ici .

La tâche 'test' ne fonctionne pas pour le plugin Android, pour le plugin Android, utilisez ce qui suit:

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

Voir ce qui suit: https://stackoverflow.com/a/31665341/3521637

Dans le prolongement de la grande réponse de Shubham, j'aime suggérer d'utiliser des valeurs d' énumération au lieu de chaînes . Veuillez consulter la documentation de la 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
    }
}

Ma version minimaliste préférée basée sur la réponse de Shubham Chaudhary.

Mettez ceci dans un build.gradlefichier:

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

Dans Gradle en utilisant le plugin Android:

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

La sortie sera alors:

Exécution du test testConversionMinutes [org.example.app.test.DurationTest] avec le résultat: SUCCESS

Fusion de la grande réponse de Shubham et JJD utilise une énumération au lieu d'une chaîne

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

Suite à la réponse de Benjamin Muschko (19 mars 2011), vous pouvez utiliser le -idrapeau avec grep pour filtrer des milliers de lignes indésirables. Exemples:

Filtre puissant - N'affiche que le nom et le résultat de chaque test unitaire, ainsi que l'état général de la construction. Les erreurs ou exceptions de configuration ne s'affichent pas.

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

Filtre souple - Affiche le nom et le résultat de chaque test unitaire, ainsi que les erreurs / exceptions de configuration. Mais il comprendra également des informations non pertinentes:

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

Filtre souple, syntaxe alternative: (les jetons de recherche sont divisés en chaînes individuelles)

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

Explication de son fonctionnement: la sortie de la première commande ./gradlew test -i,, est dirigée vers une deuxième commande grep, qui filtrera de nombreuses lignes indésirables sur la base d'une expression régulière. "-E"active le mode d'expression régulière et "|"signifie "ou". Un nom et un résultat de test unitaire peuvent s'afficher à l'aide de" > " , et l'état général est autorisé avec "BUILD". Dans le filtre souple, le "-v"drapeau signifie "ne contenant pas" et "^"signifie "début de ligne". Il supprime donc toutes les lignes commençant par "Exécuter" ou commencer par "Créer", etc.

Exemple pour les tests unitaires d'instrumentation Android, avec 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:"

Exemple de couverture de test unitaire Jacoco, avec gradle 4.10:

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

Si vous avez un DSLbuild.gradle.kts écrit dans Kotlin, vous pouvez imprimer les résultats des tests avec (je développais un projet multi-plateforme kotlin, sans plugin "java" appliqué):

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

Ajoutez simplement la fermeture suivante à votre build.gradle. la sortie sera imprimée après l'exécution de chaque test.

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