Junit 4, a famosa estrutura de testes de unidade Java, está fora há muito tempo. Naquela época, descobri que o Junit 5 estava na versão beta, então eu escreveria um artigo para apresentar o Junit 5. No entanto, porque ainda é uma versão beta, algumas partes não são perfeitas e sou um pouco preguiçoso e não as escrevo bem. De repente, lembrei -me desse incidente hoje em dia. Quando o verifiquei no site oficial, descobri que, em 10 de setembro, a versão oficial do Junit 5 finalmente foi lançada! Por acaso, escrevi o artigo novamente e apresentei a mais recente estrutura do Junit para você.
Estrutura da estrutura
Comparado com o JUNIT 4, a estrutura do JUNIT 5 é muito clara e fornece um bom suporte para funções estendidas, como plug-ins personalizados, execução de teste IDE etc. Isso pode ser visto na estrutura do projeto.
Plataforma Junit
O nome do pacote deste grupo é org.junit.platform. Como você pode ver no nome, a principal função deste grupo é servir como a plataforma básica para a estrutura de teste. Os módulos deste pacote incluem APIs básicas, mecanismos de execução e executores, funções básicas de execução da linha de comando, interfaces de linha de comando, plug-ins de teste MAVEN e GRADLE e outras funções básicas.
JUNIT JUPITER
Júpiter é o nome de código do Junit 5. Os módulos deste pacote contêm as principais funções do Junit 5. Se quisermos usar o JUNIT 5, devemos incluir esse conjunto de módulos.
Junit vintage
Vintage é o nome do código da versão antiga do Junit. Os módulos deste pacote nos permitem executar testes de antigo Junit 3 e 4 na nova plataforma Junit.
Biblioteca de classe de importação
Embora o Junit 5 ainda esteja na fase beta, há exemplos de integração do Junit 5 em Maven e Gradle na documentação oficial. Mas na versão oficial, o conteúdo desta parte desapareceu, deixando apenas dois links para o projeto de amostra, vamos nos referir a ele (copiar e colar).
Usando maven
JUNIT5-MAVEN-SUMER é o exemplo oficial do Maven. Originalmente, eu postaria a configuração do POM relevante aqui, mas quando vi que a configuração do Maven era muito longa, é melhor esquecer. Se você tiver algum requisito, verifique a configuração do POM deste projeto.
Usando gradle
Se você usar o gradle, esse problema é muito mais simples. Também existem descrições detalhadas no projeto de amostra JUNIT5-Gradle-Consumer.
Primeiro de tudo, a GRADLE não suporta o Junit 5 por padrão, portanto, o plug-in da plataforma JUNIT precisa ser ativado para apoiá-lo.
BuildScript {Repositórios {MAVENCENTRAL ()} Dependências {ClassPath 'org.junit.platform: Junit-platform-gradle-plugin: 1.0.0'}} Aplicar plugin: 'org.junit.platform.gradle.plugin'Depois, há a configuração deste plug -in gradle. Por padrão, todos os motores e tags serão executados. Se você deseja optar por executar testes apenas para certos motores e tags, poderá descomentar o seguinte e modificá -los de acordo com suas próprias necessidades. Obviamente, se você não tiver esses requisitos avançados, poderá excluir esta parte.
Junitplatform {// plataformVersion '1.0.0' filtros {mecanismos {// incluem 'Junit-Jupiter', 'Junit-Vintage' // exclui 'Custom-Engine'} tags {// Incluir 'Fast' excluir '' lento '} // incluindoClassNeSePattern'.*Test '}} arquivo ('build/teste-results/junit-platform') // Este é o padrão // LogManager 'org.apache.logging.log4j.jul.logmanager'}Se você precisar executar apenas os testes do Junit 5, basta importar as duas dependências a seguir. As dependências da plataforma JUNIT são importadas automaticamente.
Dependências {testCompile ("org.junit.jupiter: Junit-Jupiter-Api: 5.0.0") testRuntime ("org.junit.jupiter: Junit-Jupiter-Mengine: 5.0.0")}Se você deseja executar testes antigos do Junit 3 e 4 sob a nova plataforma, precisa importar as seguintes dependências.
Dependências {TestCompile ("Junit: Junit: 4.12") testRuntime ("org.junit.vintage: Junit-Vintage-Engine: 4.12.0")}Escreva testes
Teste de Junit 4
Se toda a configuração anterior estiver concluída, você poderá começar a escrever testes agora. Primeiro, vamos revisar o teste antigo do Junit 4.
public class Junit4Test {@BeFeFeClass public static void init () {System.out.println ("antes da classe");}@postclass public static void clean () {System.out.println ("After class");}@antes public void () {System.out.out. ("After Class");}@antes de public. {System.out.println ("depois");}@teste public void test1 () {System.out.println ("Test 1");}@teste public void test2 () {System.out.println ("Test 2");}}Use o teste gradle e outros comandos para executar este teste. O resultado é semelhante a isso.
Antes da classe ClassBeforeTest 1Test 2After Class
Teste de Junit 5
Vamos dar uma olhada em como escrever o teste equivalente do Junit 5. A mudança mais óbvia pode ser vista: antes de tudo, várias anotações foram renomeadas para nomes mais famosos; Outro ponto é que o método de teste não precisa ser um método público, para que possamos digitar o teclado algumas vezes.
public class Junit5test {@BeForEALL estático void beforeEall () {System.out.println ("antes de tudo");}@depois de tudo estático void depois de todos () {System.out.println ("depois de tudo");}@antes do void antes () {System.out.Println (" {System.out.println ("After");}@teste void test1 () {System.out.println ("Test 1");}@teste void test2 () {System.out.println ("Test 2");}}Escreva afirmações
Para verificar se os casos de teste estão corretos, precisamos escrever algumas afirmações. O Junit 5 vem com muitas afirmações que podem nos ajudar a escrever casos de teste. Além disso, essas afirmações vêm com versões sobrecarregadas que podem aceitar expressões Lambda, que são muito adequadas para o uso do Java 8. Claro, eu pessoalmente acho que é mais conveniente afirmar.
importar estático org.junit.assert.assertTrue; importar org.junit.jupiter.api.assertions.*; public class AssertionDemo {@Test void testAssertion () {Assertequals (10, 10); assertTrue (true); assertequais (100, 100, "dois números iguais"); assertall ("número", () -> assertequals ("nome", "nome"), () -> assertequals (500, 500)); asserthrows (invalidParameTerexception.class, () -> {lança novo invalidParameTerexception ();}); int resultado = assertTimeout (duration.ofSeconds (5), () -> {int i = 0, j = 0; while (i <= 100) {for (; j <= 100000; j ++) j ++; i ++;} retornar i;}); assertequals (100, resultado); }}Injeção de dependência
Agora, os métodos do construtor e de teste da classe de teste podem aceitar parâmetros. A interface ParameterResolver define como injetar parâmetros no tempo de execução. Vários internos nos permitem obter informações sobre o tempo de execução do caso de teste.
Primeiro é o testInfoparameterResolver. Se houver uma instância do tipo TestInfo no método, a estrutura do Junit 5 injetará automaticamente a instância. Vários métodos desta instância podem nos permitir obter o nome, o nome de exibição, a etiqueta e outras informações da classe e do método de teste.
classe pública dependencyInjectionDemo {@Test @DisplayName ("Dependency Injeção") @Tag ("test") void testDisplayName (testInfo testInfo) {assertequals ("injeção de dependência", testinfo.getDisplayName ()); assertequals (coleções.singleton ("test"), testInfo.gettags ()); }}Também existem analisadores de parâmetros embutidos, como RepetitionInfoparameterResolver, que serão introduzidos posteriormente.
Anotações comuns
nome de exibição
Podemos adicionar nomes personalizados às classes de teste e métodos de teste, que são exibidos pelos relatórios de teste e de teste. O nome da exibição não é exibido como um nome de variável. Pode ser uma corda longa contendo espaços, ou mesmo um emoji emoji.
@DisplayName ("A classe de teste pode especificar o nome de exibição") public class DisplayNameDemo {@Test @DisplayName ("O método de teste também pode especificar o nome de exibição") void testWithlongDisplayName () {} @test @displayName ("o nome da tela também pode conter emoticons (} @Test @DisPlayName (" o nome da tela pode {}}Desativar testes
A anotação @Disabled pode ser usada em classes ou métodos de teste, e o teste correspondente pode ser desativado.
@DisabledPublic Class desabilableTestDemo {@test // @desativado void testDisabled () {}}Repita o teste
Se você precisar ter um método de teste executado várias vezes, use a anotação @RePEATETTEST.
classe pública repetidaTestDemo {@RePEATETTEST (10) void testRepeated10Times () {}}Você também pode injetar uma instituição repetitiva para verificar o número atual de repetições e o número total de repetições.
public class RepeatedTestDemo {@BeforeEach void beforeEach(RepetitionInfo info) {System.out.printf("%d - %d/n" , info.getCurrentRepetition() , info.getTotalRepetitions());}@RepeatedTest(10) void testRepeated10Times() {}}Vem com tags
Quando introduzi a configuração do Gradle, eu disse que você pode optar por filtrar certos rótulos na configuração. Também é muito simples fornecer tags no código, basta usar a anotação @TAG.
@Tag ("taggedTest") classe pública tagdemo {@test @tag ("taggedTest1") void testWithTag1 () {} @Test @Tag ("taggedTest2") void testWithTag2 () {}}}Testes aninhados
Às vezes, testes aninhados podem ser necessários para indicar a relação de inclusão entre certos testes. Os testes aninhados usam a anotação @nested.
@DisplayName ("Exterior teste") classe public NtestDemo {@Test void testouter () {} @nested @displayName ("interno teste") classe innertestDemo {@test void testinner () {}}}}}Deve -se notar que apenas classes estáticas estáticas podem usar anotações aninhadas. Além disso, como o Java não permite que classes internas tenham métodos estáticos, ele não pode ter anotações @BeForEALL e @afterall. Se você deseja interromper essa limitação, precisará adicionar a anotação @TestInstance (Lifecycle.per_class) à classe interna aninhada. Para detalhes, consulte o ciclo de vida da instância de teste.
Suporte de IDE
Embora o Junit 5 tenha saído agora. No entanto, o apoio de várias cadeias de ferramentas não continuou. Atualmente, apenas o Intellij IDEA e o Eclipse 4.7 (oxigênio) adicionaram suporte ao Junit 5. Portanto, se você estiver em uma situação formal, é mais seguro usar o Junit 4.
Perguntas frequentes
Distinguir entre diferentes versões da anotação @Test
Assim como eu estava escrevendo este artigo, encontrei um problema com meu exemplo de teste. O teste não pôde ser passado e a mensagem de erro abaixo é exibida.
Falhas (1): Junit vintage: yitian.study.test.assertionDemo: InitializationError Classource [ClassName = 'yitian.study.test.assertionDemo', filePosition = null] => java.lang.Exception: MethodEmo ', deve ser público
Os alunos com bom inglês devem ser capazes de reconhecê -lo. Esta mensagem de erro diz que o método de teste deve ser público. Mas, como mencionado anteriormente, o Junit 5 cancelou essa restrição, então por que esse erro ainda ocorre? Eu olhei com cuidado e encontrei o erro. Talvez seja porque o JUNIT 4 foi muito usado no passado, então o IDE padrão é a anotação @Test, que é concluída automaticamente.
importar org.junit.test;
Este pacote é a anotação @Test no JUNIT 4. Se quisermos usar o Junit 5, precisamos da seguinte anotação @Test.
importar org.junit.jupiter.api.test;
Depois de modificá -lo, execute o teste novamente e realmente não houve problema. Obviamente, por uma questão de aprendizado e uso, também faço referência ao pacote Junit 4, então esse conflito ocorre. Se você não possui necessidades especiais, é recomendável importar apenas pacotes JUB JAR JUNIT 5 para evitar confusão. Obviamente, importar tudo isso está bem, mas você precisa ter cuidado para distingui -los e não escrever anotações Junit 4 para o Junit 5 testes. Finalmente, vou anexar meus exemplos de teste. Aqueles que estão interessados podem dar uma olhada.
Resumir
O exposto acima é o conteúdo inteiro deste artigo sobre o conteúdo relacionado ao Junit5, e espero que seja útil para todos. Amigos interessados podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!