Menu

Lista de anotações JUnit: JUnit 4 Vs JUnit 5

list junit annotations

Experimente Nosso Instrumento Para Eliminar Problemas

Este tutorial explica tudo sobre as anotações JUnit junto com uma comparação das anotações no JUnit 4 vs JUnit 5:

Aprendemos as diferentes maneiras de executar casos de teste JUnit e vimos como criar e executar um conjunto de testes em nosso tutorial anterior.

Neste tutorial, conheceremos o aspecto proeminente do JUnit que é chamado Anotações. A partir do JUnit 4, as anotações estão implementadas e tornam o JUnit muito simples, mais benéfico e muito mais fácil de usar.

Anotações é uma API Java que permite que a JVM reconheça o tipo do método definido na classe de teste. Existem 'anotações de retorno de chamada de ciclo de vida' que são frequentemente usadas.

=> Visite aqui para aprender JUnit do zero.

Anotações JUnit

O que você aprenderá:

Anotações JUnit - JUnit 4 vs JUnit 5

A execução de um teste passa por diferentes estágios do ciclo de vida, conforme mostrado abaixo:

  • Antes de iniciar um teste, existem certas atividades a serem realizadas no início de uma aula.
  • Algumas outras atividades a serem executadas antes do início da execução de um caso de teste.
  • Certas atividades que precisam ser realizadas após a execução do teste e
  • Determinadas atividades no final da execução de todos os testes em uma aula.

A fim de verificar se essas atividades são realizadas em cada estágio do ciclo de vida do Java, é necessário que haja certos métodos ou funções definidos pelo usuário no local, denominados ' métodos de retorno de chamada do ciclo de vida .

O comportamento desses métodos de retorno de chamada do ciclo de vida é determinado pelo embutido notas de retorno de chamada do ciclo de vida ' usado no JUnit.

Exemplo: Vamos tentar torná-lo ainda mais simples, relacionando esses métodos de retorno de chamada e anotações do ciclo de vida a um exemplo de testando uma máquina de venda automática de café.

  1. Um método machineReady () que verifica se água, leite e grãos de café estão disponíveis antes de ligar a máquina pode ser necessário.
  2. Outro método startMachine () que liga a máquina, pode ser necessário colocar um novo copo de papel na máquina.
  3. Um caso de teste que verifica o ‘ Água quente Opção () '.
  4. Outro caso de teste que verifica o ‘ Capuccino Opção () '.
  5. Outro caso de teste que verifica o ‘ ExpressoCoffee Opção () '.
  6. Outro método “ throwCup () ”Que joga os copos usados ​​no lixo.
  7. Um método de nível de classe “ throwTrashandSwitchOff () ”Joga o líquido residual que transborda da bandeja para a bacia e desliga a máquina.

Portanto, no exemplo acima, aqui está como o ciclo de vida do teste segue:

  • startMachine () será executado antes de cada caso de teste - Água quente (), Capuccino () e ExpressoCoffee () corre.
  • Cada um desses casos de teste também segue o método throwCup ().
  • Os métodos machineReady () e throwTrashandSwitchOff () são métodos em nível de classe executados apenas uma vez para uma classe. O método machineReady () é executado uma vez enquanto a classe inicia a execução. O método throwTrashandSwitchOff () é executado uma vez depois que todos os casos de teste concluem a execução.

Agora, surge a questão de que estes são meros métodos Java apenas, então:

o que é incompatibilidade de chave de segurança de rede
  1. Como vamos insistir na execução da JVM machineReady () apenas uma vez no nível de classe e throwTrashandSwitchOff () ao final da execução da aula?
  2. Como faremos a JVM saber que startMachine () e throwCup () precisa ser executado antes de executar cada caso de teste e após a conclusão de cada execução de caso de teste, respectivamente?
  3. Como podemos fazer a JVM identificar que os métodos Água quente (), Capuccino () e ExpressoCoffee () os casos de teste devem ser executados?

Resposta: A única resposta às perguntas acima é que as anotações de retorno de chamada do ciclo de vida fazem toda a mágica necessária.

(Por enquanto, vamos supor que estamos criando essa classe no JUnit 4)

As anotações do ciclo de vida - @BeforeClass, @AfterClass, @Before, @After, e @Teste são as verdadeiras respostas às três perguntas acima. Temos certeza de que, depois de ler as dicas abaixo, você ficará claro com as anotações de retorno de chamada do ciclo de vida e seu fluxo de trabalho.

  • Anote o método machineReady () com @Antes da aula e a JVM fará com que seja executado uma vez durante o início da aula.
  • Anote o método Jogue o lixo () com @Depois da aula e o JVM fará com que seja executado uma vez no final da aula.
  • Anote o método startMachine () com @Antes e a JVM irá executá-lo antes de cada caso de teste ser executado.
  • Anote o método throwCup () com @Depois de e a JVM irá executá-lo após a execução de cada caso de teste.
  • Anote cada um desses métodos Água quente (), Capuccino () e ExpressoCoffee () com @Teste e a JVM sabe que esses são os principais casos de teste para a classe JUnit a ser executada.

Vamos rapidamente dar uma olhada no Anotações de retorno de chamada do ciclo de vida JUnit para JUnit 4 vs JUnit 5

JUNITO 4 ANOTAÇÃOJUNITO 5 ANOTAÇÃO
@RepeatedTest1.JUnit 5 suporta a execução repetida do método de teste por um certo número de vezes usando a anotação @RepeatedTest
@Antes@BeforeEach
@Depois de@Após cada
@Antes da aula@Antes de tudo
@Depois da aula@Depois de tudo
@Teste@Teste

Fluxo de trabalho sequencial das anotações do ciclo de vida

A seguir está o fluxo de trabalho sequencial das anotações do ciclo de vida para JUnit 4:

fluxo de trabalho sequencial das anotações do ciclo de vida para JUnit 4

  1. O método anotado com @BeforeClass é executado uma vez no início da classe.
  2. O método anotado com @Before é executado antes do Testcase 1 começar.
  3. O método Testcase1 anotado com @Test é o testcase da classe.
  4. O método anotado com @After é executado após o caso de teste 1 concluir a execução.
  5. O método anotado com @Before é executado antes do caso de teste 2 começar.
  6. O método Testcase2 anotado com @Test é o testcase da classe.
  7. O método anotado com @After é executado após o Testcase 2 concluir a execução.
  8. O método anotado com @AfterClass é executado uma vez no final da classe depois que os casos de teste 1 e 2 são executados.

O fluxo de trabalho sequencial das anotações do ciclo de vida para JUnit 5 é o seguinte:

fluxo de trabalho sequencial das anotações do ciclo de vida para JUnit 5

  1. O método anotado com @BeforeAll é executado uma vez no início da aula.
  2. O método anotado com @BeforeEach é executado antes do caso de teste 1 começar.
  3. O método Testcase1 anotado com @Test é o testcase da classe.
  4. O método anotado com @AfterEach é executado após o caso de teste 1 concluir a execução.
  5. O método anotado com @BeforeEach é executado antes do caso de teste 2 começar.
  6. O método Testcase2 anotado com @Test é o testcase da classe.
  7. O método anotado com @AfterEach é executado após o caso de teste 2 concluir a execução.
  8. O método anotado com @AfterAll é executado uma vez no final da aula depois que os casos de teste 1 e 2 são executados.

Elaboração em cada anotação

Nesta seção, vamos mergulhar fundo e ter uma compreensão detalhada do que cada uma das anotações de retorno de chamada de ciclo de vida faz:

@Before (JUnit 4) / @ BeforeEach (JUnit 5):

  • O método anotado é executado antes da execução de cada método de teste na classe de teste.
  • Essa anotação pode ser usada quando você deseja ter os recursos ou dados de teste configurados antes do início de cada teste.
  • Por exemplo, se houver 5 casos de teste em uma classe de teste JUnit, o método anotado com @ Before / @ BeforeEach é executado 5 vezes antes de cada execução do caso de teste.

@After (JUnit 4) / @ AfterEach (JUnit 5):

  • O método anotado é executado após a execução de cada método de teste na classe de teste.
  • Essa anotação pode ser usada quando você deseja liberar recursos usados ​​ou dados de teste após a execução de cada caso de teste.
  • Por exemplo, se houver 5 casos de teste em uma classe de teste JUnit, o método anotado com @ After / @ AfterEach é executado 5 vezes após a execução dos casos de teste.

@BeforeClass (JUnit 4) / @ BeforeAll (JUnit 5):

  • O método anotado é executado antes que todos os métodos de teste em uma classe de teste sejam executados.
  • Essa anotação pode ser usada quando você deseja configurar recursos ou dados de teste no nível da classe.
  • Como este método é anotado com @ BeforeClass / @ BeforeAll é executado apenas uma vez para uma classe de teste e a cópia do método é compartilhada pela classe, e o método deve ser declarado estático.
  • Por exemplo, se houver 5 casos de teste em uma classe de teste JUnit, o método anotado com @ BeforeClass / @ BeforeAll é executado uma vez por classe de teste antes de iniciar qualquer caso de teste.

@AfterClass (JUnit 4) / @ AfterAll (JUnit 5):

  • O método anotado é executado depois que todos os métodos de teste em uma classe de teste são executados.
  • Esta anotação pode ser usada quando você deseja liberar os recursos usados ​​ou dados de teste no nível da classe.
  • Como este método é anotado com @ AfterClass / @ AfterAll é executado apenas uma vez para uma classe de teste e a cópia do método é compartilhada pela classe, o método deve ser declarado estático.
  • Por exemplo, se houver 5 casos de teste em uma classe de teste JUnit, o método anotado com @ AfterClass / @ AfterAll é executado uma vez por classe de teste após a conclusão da execução de todos os casos de teste.

@Test (JUnit 4 e JUnit 5):

  • A anotação @Test é comum para JUnit 4 e também para JUnit 5. Os métodos anotados representam os casos de teste na classe.
  • Pode haver vários métodos, cada um anotado com @Test em uma classe JUnit. Isso implica que uma classe pode ter vários casos de teste.
  • Existem diferentes atributos ou parâmetros para testar, qual deles pode ser aprovado. Você pode adicionar um tempo limite forçado para um caso de teste ou adicionar uma exceção. Isso será abordado em detalhes em um tutorial separado.
  • O método anotado não pode ser privado ou estático e não pode retornar nenhum valor.
  • O método @Test deve ser declarado como público no JUnit 4, enquanto o Junit 5 permite um caso de teste definido sem o modificador de acesso ‘público’, pois considera ‘sem modificador de acesso’ como ‘público’ por padrão.

Exemplo de teste básico JUNIT

Um basico 4 de junho exemplo para anotações @BeforeClass, @Before, @Test, @After e @AfterClass foi mostrado através do código com sua explicação em nosso tutorial anterior em ‘Test Fixtures’.

Vamos dar uma olhada no básico JUnit 5 Programa para demonstrar o funcionamento das anotações de retorno de chamada do Lifecycle @BeforeAll, @BeforeEach, @Test, @AfterEach e @AfterAll.

Código para JUnit5Program.java:

public class JUnit5Program { @BeforeAll public static void preClass() { System.out.println('@BeforeAll – the annotated method runs once before all other methods execute'); } @BeforeEach public void setUp() { System.out.println('_______________________________________________________ '); System.out.println('@BeforeEach – the annotated method executes before each test '); } @Test public void test_JUnit1() { System.out.println('@Test – this is test case 1'); } @Test public void test_JUnit2() { System.out.println('@Test – this is test case 2'); } @Test public void test_JUnit3() { System.out.println('@Test – this is test case 3'); } @AfterEach public void tearDown() { System.out.println('@AfterEach – the annotated method executes after each test executes'); System.out.println('_______________________________________________________ '); } @AfterAll public static void postClass() { System.out.println('@AfterAll – the annotated method runs once after all other methods execute'); } }

Na execução do arquivo de classe, o resultado abaixo aparece na janela do console.

Janela do console

Anotações adicionais - JUnit 4 x JUnit 5

Existem muitas anotações adicionais que são usadas para propósitos específicos. Veremos a lista de anotações para JUnit 4 vs JUnit 5 e a finalidade que ela serve em breve.

Haverá um tutorial detalhado sobre cada uma dessas anotações em nossos próximos tutoriais.

JUNITO 4 ANOTAÇÃOJUNITO 5 ANOTAÇÃODescrição resumida
@FixMethodOrder@TestMethodOrder & @Order1. Essas anotações permitem que o usuário escolha a ordem de execução dos métodos dentro de uma classe de teste
@Rule e @ClassRule@ExtendWith1. @Rule - A anotação é estendida da classe TestRule que ajuda a aplicar certas regras nos casos de teste.
2. Por exemplo: a criação de uma pasta temporária antes da execução do caso de teste e a exclusão da pós-execução da pasta podem ser definidas por meio de uma regra.
3. @Rule está disponível apenas no JUnit 4, que pode ser usado no JUnit 5 Vintage, no entanto, @ExtendWith fornece um recurso mais próximo para o JUnit 5
4. Da mesma forma, um tempo limite global pode ser definido usando @Rule.
N / D@TestFactory1. Essa anotação é suportada apenas pelo JUnit 5 e ajuda na criação de testes dinâmicos ou de tempo de execução.
2. Ele retorna um fluxo de dados como coleta e não pode usar anotações de retorno de chamada do ciclo de vida
N / D@Nested1. Esta anotação é compatível apenas com JUnit Jupiter
2. Isso nos ajuda a criar casos de teste aninhados.
3. Por exemplo, a Classe 1 com o caso de teste 1 pode ter um @Nested Class 2 com o caso de teste 2. Isso torna o caso de teste 2 um caso de teste aninhado para o caso de teste 1. Portanto, o caso de teste 1 é executado, então o caso de teste 2 é executado.
4.Se a anotação @Nested não for usada, a classe aninhada não será executada.
@Categoria@Marcação1. Esta anotação ajuda a marcar e filtrar os testes
2.Você pode incluir testes para execução ou excluí-los filtrando com base nas categorias em que se enquadram.
@RunWith (Parameterized.class)
@ Parameterized.Parameters		@ParameterizedTest e @ValueSource1. Esta anotação é usada para executar um método com variações de dados de teste várias vezes.
2.JUnit 4 suporta @RunWith e @Parameters enquanto JUnit 5 Jupiter suporta @ParameterizedTest com @ValueSource
@Nome em Exibição1. Um nome definido pelo usuário pode ser dado a um método ou classe de teste para fins de exibição.
@TestInstance (LifeCycle.PER_CLASS) e @TestInstance (LifeCycle.PER_METHOD)1. O JUnit 5 oferece suporte à configuração do ciclo de vida dos testes.
2. A JUnit 4 e a 5 seguem o retorno de chamada do ciclo de vida do método padrão, enquanto a configuração por classe também pode ser feita.

Referências => JUnit 4 , JUnit 5

Conclusão

  1. Aprendemos sobre as anotações de retorno de chamada do ciclo de vida e o fluxo de trabalho sequencial no qual os métodos de teste são executados com base em suas anotações.
  2. Aprendemos as anotações usadas para JUnit 4 e as anotações para JUnit 5.
  3. Também aprendemos sobre anotações adicionais que JUnit 4 suporta e aquelas que suportam JUnit 5 apenas.

=> Cuidado com a série de treinamento JUnit simples aqui.

Leitura recomendada

^