Gostaria de ver os resultados dos testes (system.out / err, mensagens de log dos componentes que estão sendo testados) enquanto eles são executados no mesmo console que eu executo:

gradle test

E não espere até que os testes sejam concluídos para examinar os relatórios de teste (que são gerados somente quando os testes são concluídos, portanto, não posso "f-tail" de nada enquanto os testes estão em execução)

Você pode executar o Gradle com o nível de log INFO na linha de comando. Ele mostra o resultado de cada teste enquanto eles estão em execução. A desvantagem é que você obterá muito mais saída para outras tarefas também.

gradle test -i

Aqui está a minha versão chique:

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

Você pode adicionar um fechamento Groovy dentro do arquivo build.gradle que faz o log para você:

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

No seu console, ele fica assim:

: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

Desde a versão 1.1 Gradle suporta muito mais opções para registrar a saída do teste . Com essas opções em mãos, você pode obter uma saída semelhante com a seguinte configuração:

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

Como stefanglase respondeu:

adicionar o código a seguir ao build.gradle(desde a versão 1.1) funciona bem para saída em testes aprovados , ignorados e com falha .

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

O que quero dizer adicionalmente (descobri que isso é um problema para iniciantes) é que o gradle testcomando executa o teste apenas uma vez por alteração .

Então, se você estiver executando o segunda vez, não haverá saída nos resultados do teste . Você também pode ver isso na saída do edifício: gradle diz UP-TO-DATE nos testes. Portanto, não é executado pela n-ésima vez.

Gradle inteligente!

Se você deseja forçar a execução dos casos de teste, use gradle cleanTest test .

Este tópico está um pouco fora do tópico, mas espero que ajude alguns novatos.

editar

Como sparc_spread afirmou nos comentários:

Se você deseja forçar o gradle a executar sempre novos testes (o que nem sempre é uma boa idéia), você pode adicionar outputs.upToDateWhen {false}a testLogging { [...] }. Continue lendo aqui .

Paz.

Isenção de responsabilidade: Eu sou o desenvolvedor do Gradle Test Logger Plugin.

Você pode simplesmente usar o Gradle Test Logger Plugin para imprimir belos logs no console. O plug-in usa padrões sensatos para satisfazer a maioria dos usuários com pouca ou nenhuma configuração, mas também oferece vários temas e opções de configuração para todos os gostos.

Exemplos

Tema padrão

Tema Mocha

Uso

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

Certifique-se de sempre obter a versão mais recente do Gradle Central .

Configuração

Você não precisa de nenhuma configuração. No entanto, o plugin oferece algumas opções. Isso pode ser feito da seguinte maneira (valores padrão mostrados):

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
}

Espero que você goste de usá-lo.

Adicione isto para build.gradleimpedir que o gradle engula stdout e stderr.

test {
    testLogging.showStandardStreams = true
}

Está documentado aqui .

A tarefa 'test' não funciona para o plug-in Android; para o plug-in Android, use o seguinte:

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

Veja o seguinte: https://stackoverflow.com/a/31665341/3521637

Como acompanhamento da grande resposta de Shubham, eu gostaria de sugerir o uso de valores enum em vez de strings . Por favor, dê uma olhada na documentação da 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
    }
}

Minha versão minimalista favorita baseada na resposta Shubham Chaudhary.

Coloque isso no build.gradlearquivo:

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

Em Gradle usando o plug-in Android:

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

Então a saída será:

Executando o teste testConversionMinutes [org.example.app.test.DurationTest] com o resultado: SUCCESS

A mescla da grande resposta de Shubham e o JJD usam enum em vez de 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))
           }
       }
   }
}

Seguindo a resposta de Benjamin Muschko (19 de março de 2011), você pode usar a -ibandeira junto com o grep , para filtrar milhares de linhas indesejadas. Exemplos:

Filtro forte - Exiba apenas o nome e o resultado de cada teste de unidade e o status geral da compilação. Erros ou exceções de instalação não são exibidos.

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

Filtro suave - Exiba o nome e o resultado de cada teste de unidade, bem como os erros / exceções de configuração. Mas também incluirá algumas informações irrelevantes:

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

Filtro suave, sintaxe alternativa: (os tokens de pesquisa são divididos em sequências individuais)

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

Explicação de como funciona: A saída do primeiro comando ./gradlew test -i,, é canalizada para um segundo comando grep, que filtrará muitas linhas indesejadas com base em uma expressão regular. "-E"ativa o modo de expressão regular e "|"significa "ou". É permitido exibir um nome e um resultado do teste de unidade usando " > ", e o status geral é permitido com "BUILD". No filtro flexível, o "-v"sinalizador significa "não contém" e "^"significa "início da linha". Portanto, remove todas as linhas que começam com "Executando" ou com "Criando" etc.

Exemplo para testes de unidade de instrumentação Android, com 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:"

Exemplo de cobertura de teste de unidade Jacoco, com gradle 4.10:

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

Se você possui um DSLbuild.gradle.kts escrito no Kotlin, pode imprimir os resultados dos testes (eu estava desenvolvendo um projeto de plataforma múltipla do kotlin, sem o plugin "java" aplicado):

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

Basta adicionar o seguinte fechamento ao seu build.gradle. a saída será impressa após a execução de cada teste.

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