Por que o executor de teste do Android está relatando “Conjunto de testes vazio”?

Estou batendo minha cabeça contra a parede aqui tentando descobrir por que o IntelliJ / Android está relatando "Conjunto de testes vazio". Eu tenho um pequeno projeto com dois Módulos IntelliJ ("Projetos" no Eclipse). O módulo de teste de unidade tem seu próprio AndroidManifest.xml, que colei na parte inferior. Estou tentando executar um ActivityUnitTestCase, pois os testes dependerão do Contextobjeto-.

O nome do pacote do módulo principal é nilzor.myapp. O nome pacakge do módulo de teste énilzor.myapp.tests

Por que o testBlah()executor de teste não está detectando o -método como um teste?

<?xml version="1.0" encoding="utf-8"?>
<!-- package name must be unique so suffix with "tests" so package loader doesn't ignore us -->
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="nilzor.myapp.tests"
          android:versionCode="1"
          android:versionName="1.0">
    <!-- We add an application tag here just so that we can indicate that
         this package needs to link against the android.test library,
         which is needed when building test cases. -->
    <application>
        <uses-library android:name="android.test.runner"/>
    </application>
    <!--
    This declares that this application uses the instrumentation test runner targeting
    the package of nilzor.myapp.  To run the tests use the command:
    "adb shell am instrument -w nilzor.myapp.tests/android.test.InstrumentationTestRunner"
    -->
    <instrumentation android:name="android.test.InstrumentationTestRunner"
                     android:targetPackage="nilzor.myapp"
                     android:label="Tests for nilzor.myapp"/>
</manifest>

E aqui está minha aula de teste :;

package nilzor.myapp.tests;

public class NilzorSomeTest<T extends Activity> extends ActivityUnitTestCase<T>{
    public NilzorSomeTest(Class<T> activityClass){
        super(activityClass);
    }

    @SmallTest
    public void testBlah(){
        assertEquals(1,1);
    }
}

Eu li os fundamentos do teste , o documento de teste de atividade e tentei seguir este blog de teste Hello world , embora seja para o Eclipse. Não consigo fazer o executor de teste localizar e executar meu teste. O que estou fazendo de errado?

Algumas das perguntas sobre as quais ainda não tenho certeza são:

1. Eu preciso de uma anotação acima do método de teste de unidade?
2. Preciso prefixar o método com "teste" ou é apenas para testes JUnit?
3. Posso ter testes em subpacotes de nilzor.myapp.tests?

Mas a questão principal desta postagem é por que o executor de teste não detecta meu teste ?

Você precisa fornecer o construtor padrão para sua classe de teste, por exemplo:

package nilzor.myapp.tests;

public class NilzorSomeTest extends ActivityUnitTestCase<ActivityYouWantToTest>{
    public NilzorSomeTest(){
        super(ActivityYouWantToTest.class);
    }

    @SmallTest
    public void testBlah(){
        assertEquals(1,1);
    }
}

sobre suas outras questões:

1. Não. Meus testes ainda são executados sem quaisquer anotações, mas acho que é uma boa prática tê-los. Ele permite que você especifique o tamanho dos testes a serem executados. Consulte Qual é a finalidade das anotações @SmallTest, @MediumTest e @LargeTest no Android? para mais detalhes.

2. Sim, você precisa do prefixo "teste". O InteliJ fornece um aviso de "método nunca usado" quando não há prefixo de "teste" e pula esse método durante a execução do teste.

3. Sim. Tenho meus testes organizados em subpacotes e parece estar funcionando bem.

Se isso estiver acontecendo "de repente" ou "estava funcionando 5 minutos atrás", minha solução era ir para as configurações Executar / Depurar e remover todas as configurações em "Testes Android". Às vezes, essas configurações são corrompidas se eu refatorar a classe em teste (por exemplo, mudando para um novo pacote).

Nenhuma das opções acima corrigiu para mim. O que ajudou foi seguir as instruções :

Crie uma configuração de teste

No Android Studio:

• Abra o menu Executar -> Editar Configurações
• Adicionar uma nova configuração de testes Android
• Escolha um módulo
• Adicione um executor de instrumentação específico:

  android.support.test.runner.AndroidJUnitRunner

Execute a configuração recém-criada.

Eu tive uma questão semelhante. Não sei por que isso está ocorrendo, mas fui capaz de corrigir indo em: "Arquivo"> ​​"Invalidar caches / reiniciar" no Android Studio.

Não sei se isso ajuda para o Android Studio, mas tive algum tipo de conflito Intellij-Gradle. Resolvido "clicando com o botão direito" no arquivo de teste e clicando em "compilar arquivo ... Test.java". Depois disso, eu poderia executar testes únicos novamente.

Tive o mesmo problema no Android Studio 2.3.1, mas era apenas um bug do AS. Executar o mesmo teste na versão 2.2.1 funciona bem.

Se você estiver executando o Android Studio apenas no canal Cannary, recomendo que você também instale uma versão estável. http://tools.android.com/tips/using-multiple-android-studio-versions

Eu tinha testes que estavam funcionando bem até o gradleAndroid Studio ser atualizado.

Além de adicionar um construtor padrão aos seus testes, você pode precisar fazer algumas dessas coisas para fazer seu conjunto de testes funcionar

Em src/criar androidTest/java/<your-package-name>/test. Observe o androidTest. Qualquer outra coisa incluindo instrumentTestnão funcionará.

Adicione isto a build.gradle

sourceSets {
    testLocal {
        java.srcDir file('src/androidTest/java')
        resources.srcDir file('src/androidTest/resources')
    }
}



android{
    sourceSets {
       instrumentTest.setRoot('src/androidTest/')
    }
}

dependencies{
     testLocalCompile 'junit:junit:4.11'
}

task localTest(type: Test, dependsOn: assemble) {
    testClassesDir = sourceSets.testLocal.output.classesDir

    android.sourceSets.main.java.srcDirs.each { dir ->
        def buildDir = dir.getAbsolutePath().split('/')
        buildDir = (buildDir[0..(buildDir.length - 4)] + ['build', 'classes', 'debug']).join('/')

        sourceSets.testLocal.compileClasspath += files(buildDir)
        sourceSets.testLocal.runtimeClasspath += files(buildDir)
    }

    classpath = sourceSets.testLocal.runtimeClasspath
}

check.dependsOn localTest

Adicione isto ao AndroidManifest.xml

 <instrumentation
        android:name="android.test.InstrumentationTestRunner"
        android:label="Tests for my packaged app"
        android:targetPackage="<my-package-name>.test" />

Para o Intellij 15, resolvi esse problema:

1. Abrindo as configurações de 'Estrutura do Projeto'
2. Clicar em 'Módulos' (à esquerda)
3. Guia 'Fontes'
   a. Clique com o botão direito no diretório de origem (geralmente src) e clique em 'Código-fonte'.
   b. Clique com o botão direito no diretório de teste e clique em 'Teste'
   c. Clique com o botão direito no diretório de saída e clique em 'Excluído'
4. Vá para a guia 'Caminhos'
   a. Clique no botão de opção 'Usar caminho de saída de compilação do módulo'
   b. Selecione o diretório do caminho de saída para 'Caminho de saída'
   c. Selecione o diretório do caminho de teste para 'Caminho de saída de teste'
5. Clique OK

Obviamente, você precisa de um dispositivo de destino para executar seus testes, pois são testes instrumentados. Por alguns motivos, o Android Studio às vezes não pede que você aponte para este dispositivo de destino e apenas exiba a mensagem "Pacote de teste vazio". Existem diferentes maneiras de corrigir isso, aqui estão algumas:

• execute seu aplicativo principal e selecione um dispositivo de destino ou

• vá para a configuração Executar (Executar / Executar ... / Editar Configurações) e modificar as Opções de Destino de Implementação

No meu caso, nenhuma das respostas anteriores funcionou. A solução foi simplesmente mover a classe de teste para outro pacote .

Isso aconteceu em androidTest/

No meu caso, esse problema foi causado devido a um erro no meu código, na verdade, estava na classe do aplicativo, então a atividade de destino não foi aberta e as impressões de saída de teste

Erro de suite de teste vazio

Tentei executar testes diretamente do terminal com adb shell am instrument -w -r -e package your.package -e debug false android.support.test.runner.AndroidJUnitRunner. Com isso, ele imprime para você muito mais sobre exceção.

Tive este problema porque tinha no meu build.gradle:

testOptions {
    execution "ANDROID_TEST_ORCHESTRATOR"
}

Mesmo que eu não estivesse usando o Android Test Orchestrator (devo ter copiado os tutoriais por engano).

Comentar isso resolveu para mim.

Nenhuma das outras soluções funcionou para mim, mas consegui fazer isso funcionar simplesmente desinstalando o aplicativo ou suíte de testes existente e executando os testes.

No meu caso, o projeto em que estava trabalhando tinha alguns módulos. Nenhuma das soluções que encontrei para esse erro me ajudou e, de alguma forma, percebi que, se adicionasse as dependências de teste em AMBOS os arquivos build.gradle, os testes magicamente começaram a funcionar. Não importa se seus testes residem em apenas um dos módulos, ambos os arquivos gradle devem incluir as dependências e o valor testInstrumentationRunner.

Então, se como eu, nenhuma das outras respostas o ajudou, tente adicionar estas linhas ao arquivo build.gradle de cada um dos seus módulos:

android {    
    ....
    defaultConfig {
        ...
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }  
}

e também adicione:

dependencies {
    ...
    // Test
    androidTestCompile 'com.android.support:support-annotations:23.4.0'
    androidTestCompile 'com.android.support.test:runner:0.5'
    androidTestCompile 'com.android.support.test:rules:0.5'

}

Acabei de renomear o arquivo e o problema foi corrigido.

Eu tive o mesmo problema, e o motivo foi que minha classe de teste não tinha Teste no final do nome da classe!

Meu problema foi causado por uma exceção lançada no @BeforeClassmétodo do meu caso de teste. De alguma forma, não estava causando a falha do teste - eu só encontrei inspecionando a saída do logcat.

Corrigi a exceção e de repente meus testes estavam em execução!

Depois de enfrentar o problema hoje - não conseguir executar os testes instrumentados do Android com o erro do pacote vazio - encontrei um problema git sobre esse problema e, graças a Stephan Linzner, pude executar os testes.

tl; dr Você deve clicar com o botão direito do mouse no pacote de teste e não na classe para que os testes sejam executados.

Referência: https://github.com/googlecodelabs/android-testing/issues/27#issuecomment-219074863

Este artigo me ajudou: Conjunto de testes vazio

Basicamente, tive que criar um pacote - instrumentTest / java - em meu diretório src e colocar todos os testes lá. Então, eu poderia executar esses testes individualmente.

Eu tinha um projeto Java bruto onde isso estava ocorrendo. Simplesmente Java + JUnit4. Definitivamente reside em algo em seus arquivos .idea / ou .iml. Eu descartei o meu, reimportei e, finalmente, os testes foram executados novamente.

A classe de teste pode ser excluída da compilação. Corrija-o em setting-compiler-exclude.

Aqui estão minhas etapas de depuração que eu sigo quando o Android Studio de repente decide parar de executar / depurar testes (e cara, isso acontece com muita frequência!):

• Construir: → Reconstruir projeto
• Reiniciar dispositivo: reinicie seu dispositivo / emulador e tente novamente
• Troca de dispositivo: se você tiver um telefone comum e um emulador, desconecte um e tente executá-lo com apenas um dos dispositivos
• Android Studio: Arquivo -> Invalide caches e reinicie
• Activity Monitor / Task Manager: classifique os processos por nome, veja se há um processo sem nome que está usando muita memória RAM, este é um processo "fantasma" do Android Studio que deve ser eliminado
• git revert: tente esconder / reverter seu código mais recente. Às vezes, ocorre um erro de compilação que o Android Studio / gradle perde e ele apenas tenta executar um código não compilável.
• Desinstale e reinstale o Android Studio.

Vou adicionar mais correções à medida que as encontrar!

Não fiz nada e o problema foi embora depois de meio dia de dor, abri e fechei os projetos várias vezes, executei cada teste de aula manualmente, talvez tenha resolvido o meu problema.

No Android Studio com estrutura spock, mudei a versão do meu gradle de 2.2.2 para 3.2.1 e tudo vai bem.

A resposta aceita não resolveu meu problema. Portanto, decidi copiar o ExampleInstrumentedTestque é criado por padrão no Android Studio e executar sem problemas, renomeei-o durante o processo de cópia (sem Refatorar-> Renomear após copiar!) E colei o conteúdo do meu teste de unidade nele. Depois disso, o erro desapareceu.

Eu encontrei o erro "Conjunto de testes vazio" ao tentar executar testes de unidade locais em meu projeto Android Studio 3.0.

Depois de ler a documentação do desenvolvedor Android , percebi rapidamente que o problema era causado pela minha configuração do gradle, que incluía as seguintes linhas.

testImplementation 'com.android.support.test:runner:0.5'
testImplementation 'com.android.support.test:rules:0.5'

A classe AndroidJUnitRunner é um executor de teste JUnit que permite executar classes de teste no estilo JUnit 3- ou JUnit 4 em dispositivos Android .

Como meus testes eram locais e, portanto, não precisavam ser executados em nenhum dispositivo, a remoção das entradas com.android.support.test ... acima me permitiu executar os testes de unidade.

Eu estava fazendo algumas inserções em um banco de dados no método @BeforeClass. Percebi que tinha um problema de mapeamento de objeto / banco de dados. Esse problema de mapeamento de dados foi a causa desse problema para mim.

No meu caso, fiz meus testes de instrumentação androidTest/java/<package.name>/MyTestingClass, mas configurei minha variante de compilação atual para "pré-produção". E aí está o ponto! Conforme especificado na documentação do Android Studio :

Por padrão, todos os testes são executados no tipo de compilação de depuração.

A mensagem Class not found. Empty test suite.continuou aparecendo até que eu fiz isso:

1. Adicione esta linha ao meu build.gradle :

   android{
       [...]
       testBuildType "preproduction"
   }

2. Gradle sincronizado.
3. Exclua minhas configurações de teste anteriores, pois elas não levam em consideração a sincronização do Gradle.

Então eu executei os testes novamente e desta vez eles rodaram perfeitamente !!!

Isso aconteceu comigo quando marquei por engano uma variável de classe não simulada com a anotação. @Mock Removida a anotação e os testes foram executados com êxito. Isso aconteceu com o Junit 4.5 no Android Studio

Não é uma solução, mas uma solução alternativa que o colocará de volta no caminho certo rapidamente:

1. Em primeiro lugar, encontre um teste que funcione. Eu estava escrevendo um novo teste onde obtive o erro 'suite de teste vazia'. Fiz outros testes e eles funcionaram normalmente.

2. Copie o arquivo de teste que funciona. Execute-o para garantir que a cópia funcione como o original.

3. Remova o corpo e substitua-o pelo seu novo código de teste.

O teste agora deve funcionar.

Passamos cerca de duas horas tentando encontrar a causa, mas sem sucesso.