IDEA IntelliJ com Junit 4.7 “!!! JUnit versão 3.8 ou posterior esperado: ”

Quando tento executar o seguinte teste no IntelliJ IDEA , recebo a mensagem:

"!!! JUnit versão 3.8 ou posterior esperado:"

Note-se que este é um projeto Android no qual estou trabalhando no IntelliJ IDEA 9.

public class GameScoreUtilTest {
    @Test
    public void testCalculateResults() throws Exception {
        final Game game = new Game();

        final Player player1 = new Player();
        {
            final PlayedHole playedHole = new PlayedHole();
            playedHole.setScore(1);
            game.getHoleScoreMap().put(player1, playedHole);
        }
        {
            final PlayedHole playedHole = new PlayedHole();
            playedHole.setScore(3);
            game.getHoleScoreMap().put(player1, playedHole);
        }
        final GameResults gameResults = GameScoreUtil.calculateResults(game);

        assertEquals(4, gameResults.getScore());
    }
}

O rastreamento de pilha completa se parece com isso ...

!!! JUnit version 3.8 or later expected:

java.lang.RuntimeException: Stub!
    at junit.runner.BaseTestRunner.<init>(BaseTestRunner.java:5)
    at junit.textui.TestRunner.<init>(TestRunner.java:54)
    at junit.textui.TestRunner.<init>(TestRunner.java:48)
    at junit.textui.TestRunner.<init>(TestRunner.java:41)
    at com.intellij.rt.execution.junit.JUnitStarter.junitVersionChecks(JUnitStarter.java:152)
    at com.intellij.rt.execution.junit.JUnitStarter.canWorkWithJUnitVersion(JUnitStarter.java:136)
    at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:49)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    at java.lang.reflect.Method.invoke(Method.java:597)
    at com.intellij.rt.execution.application.AppMain.main(AppMain.java:110)

Process finished with exit code -3

Esse problema ocorre porque a plataforma Android ( android.jar) já contém classes JUnit. O executor de teste do IDEA carrega essas classes e vê que são do JUnit antigo, enquanto você tenta usar testes anotados, que são um recurso do novo JUnit, portanto, obtém o erro do executor de teste.

A solução é simples, abra o Project Structure| Modules| Dependenciese mova a junit-4.7.jarseta para cima, para que ela seja apresentada antes Android 1.6 Platform no caminho da classe. Agora, o executor de testes ficará feliz ao carregar a nova versão do JUnit.

meu módulo é um módulo de biblioteca java, portanto, alterar o JRE para 1,8 java resolveu o problema.

Ou você também pode fazer isso globalmente em Configurações do módulo> Localização do SDK> JDK, especificando o JDK 8 do Oracle em vez da cópia do SDK do Android.

Eu tive esse problema com um projeto de vários módulos (libgdx). Um módulo é Java puro e possui testes. Minha solução foi definir "use JRE alternativo" como "Java 1.8" na configuração de execução dos meus testes de unidade. Isso garante que nenhum android.jar esteja no caminho de classe e que o junit 4.x runner seja usado.

Eu recebi o mesmo erro ao criar ambos Unit Teste Android Instrument Testno Android Studio 1.4 ou superior e ele começou a ficar confuso. Para evitar esse erro, verifique se sua classe de teste está inserida Android TestsemRun/Debug Configurations

1. Certifique-se de seguir as instruções corretamente https://developer.android.com/training/testing/unit-testing/instrumented-unit-tests.html
2. Certifique-se Test ArtifactdeBuild Variants está definido comoAndroid Instrumentation Tests
3. Clique no menu Run >Edit Configuration
4. Verifique se o nome da sua classe / método está dentro Android Tests vez deJUnit
5. Se estiver JUnitsimplesmente exclua a configuração e clique com o botão direito do mouse no arquivo que deseja testar e Runnovamente. Ele criará a configuração na Android Testsseção e será executada no dispositivo / emulador.

Para Android Studio - a partir do Android Studio 1.1 Beta 4 , o Google adicionou suporte para o Android Gradle plugin 1.1.0-RC . O novo plug-in é compatível com o Teste de unidade por meio do Android Studio usando junho 4+.

Isso ainda é experimental e existem algumas etapas manuais para configurar isso.

Para todos que estão lendo esta postagem e ainda têm o mesmo problema com o AndroidStudio 1.0. Você não pode alterar a ordem de dependência no AndroidStudio, pois o IDE os reescreve automaticamente. E, mesmo se você conseguir alterar a ordem modificando o arquivo .iml, receberá uma "classe não encontrada ...". Isso ocorre porque o caminho de saída de teste não pode ser definido no AndroidStudio.

Na verdade, existe uma solução para fazer AndroidStudio, Junit e Robolectric trabalhando juntos. Dê uma olhada neste https://github.com/JCAndKSolutions/android-unit-test e use este plugin também: https://github.com/evant/android-studio-unit-test-plugin

Funciona perfeitamente para mim.

Eu recebi o mesmo erro ao criar meu próprio pacote junit

Para corrigir isso, adicionei essas duas linhas no arquivo gradle do aplicativo, conforme explicado aqui :

dependencies {
    ...
    // Required -- JUnit 4 framework
    testCompile 'junit:junit:4.12'
    // Optional -- Mockito framework
    testCompile 'org.mockito:mockito-core:1.10.19'
}

Há duas coisas que eu poderia imaginar

• Se o seu IDE tentar iniciar um teste do Android Junit que seja executado diretamente no emulador, você não poderá usar o Junit4.
• Se você acidentalmente usou as classes junit fornecidas no jar do android, elas não podem ser executadas em uma jvm normal, porque existem apenas classes reais compiladas para o dalvik vm do android.

Isso aconteceu comigo também no Android Studio 1.1 - embora deva suportar testes de unidade sem um plug-in.

Em outras máquinas (mesmo projeto, mesma versão do AS), descobri que, ao executar testes de unidade, o IDE não adiciona o arquivo android.jar ao caminho de classe, enquanto o faz na máquina.

Meu melhor palpite foi que, devido à conversão que fizemos de Maven para Gradle e passando de intellij para AS, algum cache de configurações permaneceu em algum lugar da minha máquina que fez com que android.jar fosse adicionado ao caminho de classe.

O que fiz foi limpar todos os caches relacionados ao Android da minha máquina (na pasta c: \ users \ USRE_NAME): .android .AndroidStudio .gradle .m2

Depois disso, reabri o projeto e os testes funcionaram.

Ainda tentando entender o que deu errado, mas isso deve funcionar por enquanto.

Eu tive esse problema no Android Studio 1.5, porque não sabia que precisava alterar a configuração "Artefato de teste" nas "Variantes de compilação" (canto inferior esquerdo da janela principal) de "Testes de instrumentação do Android" para "Testes de unidade " Ao fazê-lo, você pode ver um arquivo ExampleUnitTest.java na janela Projeto.

Eu tive o mesmo problema, mas por outro motivo. Eu estava no IntelliJ com um projeto java gradle regular (não android), mas o JDK foi definido como SDK para Android Project Structure(era o JDK padrão por alguns motivos). Isso é realmente idiota, mas o IntelliJ não foi bom o suficiente para me indicar o que há de errado, então fiquei preso nisso.

Foi assim que eu resolvi:

Editar configurações -> padrões -> JUnit Android -> adicione o seguinte ao diretório de trabalho:

$ MODULE_DIR $

Para mim, esse problema foi causado por uma configuração de execução desatualizada / quebrada para os testes. Eu simplesmente tive que excluir a configuração, criar uma nova e o problema foi corrigido.

No projeto Android que eu tinha minifyEnabled = true, depois que mudei para falsetudo funcionou.

Se você remover

testOptions {
    unitTests.returnDefaultValues = true
}

do seu build.gradlevai funcionar

Vá para Estrutura do projeto -> Configuração da plataforma, altere os SDKs para 1,8 e resolvi o meu problema.

Eu também estava enfrentando o mesmo problema, depois de mudar para build.gradle, está funcionando bem para mim.

altere sua versão junit dentro de build.gradle para:

    testImplementation 'junit:junit:3.8'

Eu segui a resposta do CrazyCoder, mas não havia nenhum arquivo junit mostrado nas dependências. então baixei um de http://www.java2s.com/Code/Jar/j/Downloadjunitjar.htm e adicionei-o pressionando o botão de adição à direita. E funcionou

Desativar "Usar JDK incorporado" na Estrutura do Projeto / Localização do SDK é o que ajudou no meu caso, mas não sei exatamente qual foi o motivo pelo qual ele estava falhando.

Substitua seu android.jar na pasta libs pela última. Você pode baixá-lo aqui

Em AndroidStudio, Open Project Structure -> SDK Location, você pode ver JDKlocalização, uso mudança "Use incorporado JDK" para você possui JDKpara aplicar, em seguida, mudar de volta para "JDK Use incorporado" , é talvez o trabalho

No meu caso, a alteração JREda Run Configurationsdose resolve o problema, mas quando clico no botão de execução ao lado da função de teste, as JREopções são redefinidas para o padrão.

Por fim, semelhante à resposta de @CrazyLiu, em Project Structure - SDK Location - JDK, selecione Embedded JDK. Porque não há caixa de seleção no Android Studio 3.6.

Eu recebi a mesma mensagem

JUnit version 3.8 or later expected

por um simples erro de iniciante. Eu tinha usado os mesmos nomes de pacote e nomes de classe em src / main e src / test para uma classe (a classe HomeController no meu caso):

my-test-project
  +--pom.xml
  +--src
    +--main
      +--com
        +--example
          +--Application.java
          +--controller
            +--HomeController.java
    +--test
      +--com
        +--example
          +--ApplicationTest.java
          +--controller
            +--HomeController.java  <---- same package and class name: not good!

Com isso, a classe src / main HomeController, bem como a classe src / test HomeController, tiveram o mesmo caminho completo:

com.example.controller.HomeController.class

O resultado: todos os testes dependentes da classe HomeController falharam.

Alterar o nome do pacote e / ou o nome da classe resolveu o problema. Aqui o exemplo, quando ambos, o nome do pacote e o nome da classe são alterados:

my-test-project
  +--pom.xml
  +--src
    +--main
      +--com
        +--example
          +--Application.java
          +--controller
            +--HomeController.java
    +--test
      +--com
        +--example
          +--test                       <---- added (optional)
            +--ApplicationTest.java
            +--controller
              +--HomeControllerTest.java    <---- changed

Agora, os nomes de classe totalmente qualificados diferem. O nome da classe src / main HomeController é:

com.example.controller.HomeController.class

e o nome da classe src / test HomeHontrollerTest é:

com.example.test.controller.HomeControllerTest.class

Como os nomes de classe totalmente qualificados são únicos, o problema desaparece.