JUnit Casos de teste @Before @BeforeClass Anotação

JUnit é a unidade mais popular Testes quadro em Java. É explicitamente recomendado para Teste de Unidade. JUnit Não requer um servidor para testar uma aplicação web, o que torna o processo de teste rápido.

O JUnit framework também permite a geração rápida e fácil de casos de teste e dados de teste. O org.junit O pacote consiste em várias interfaces e classes para JUnit testes, como Testar, Assert, After e Before. O mais amplo JUnit A família se constrói sobre esses mesmos alicerces.

O que é um dispositivo de teste?

Antes de entendermos o que é um conjunto de testes (test fixture), vamos estudar o código abaixo.

Este código foi projetado para executar dois casos de teste em um arquivo simples.

public class OutputFileTest {
    private File output; 
    output = new File(...);
    output.delete(); 
public void testFile1(){
        //Code to verify Test Case 1
}
    output.delete();
    output = new File(...);
public void testFile2(){
        //Code to verify Test Case 2
}
 output.delete(); 
}

Alguns problemas aqui

• O código não é legível.
• O código não é fácil de manter.
• Quando o conjunto de testes é complexo, o código pode conter problemas lógicos.

Compare o mesmo código usando JUnit.

public class OutputFileTest		
{
    private File output; 
    @Before public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

O código é muito mais legível e fácil de manter. A estrutura de código acima é um exemplo. dispositivo de teste.

Um acessório de teste é um contexto onde um JUnit Caso de teste corre. Normalmente, os acessórios de teste incluem:

• Objetos ou recursos disponíveis para qualquer caso de teste.
• Atividades necessárias para disponibilizar esses objetos e recursos.
• Essas atividades são
  1. alocação (instalação)
  2. desalocação (teardown).

Configuração e desmontagem

Os jogos são importantes porque JUnit Esses recursos são aplicados em todos os testes.

• Normalmente, existem algumas tarefas repetidas que devem ser realizadas antes de cada caso de teste. Exemplo: crie uma conexão de banco de dados.
• Da mesma forma, ao final de cada caso de teste, pode haver algumas tarefas repetidas. Exemplo: para limpar quando a execução do teste terminar.
• JUnit Fornece anotações que auxiliam na configuração e desmontagem. Garante que os recursos sejam liberados e que o sistema de teste esteja pronto para o próximo caso de teste.

Estes JUnit As anotações são discutidas abaixo.

instalação

@Antes anotação em JUnit é usado em um método contendo Java Código a ser executado antes de cada caso de teste, ou seja, ele é executado antes da execução de cada teste.

Desmontagem (independentemente do veredicto)

@Depois de A anotação é usada em um método que contém Java Código a ser executado após cada caso de teste. Esses métodos serão executados mesmo se alguma exceção for lançada no caso de teste ou em caso de falhas de asserção.

Observação:

• É permitido ter qualquer número de anotações listadas acima.
• Todos os métodos anotados com @Antes in JUnit serão executados antes de cada caso de teste, mas poderão ser executados em qualquer ordem.
• Você pode herdar os métodos `@Before` e `@After` de uma superclasse. A execução é a seguinte e trata-se de um processo de execução padrão em JUnit.

1. Execute o JUnit Métodos @Before na superclasse
2. Execute os métodos @Before nesta classe
3. Execute um método @Test nesta classe
4. Execute os métodos @After nesta classe
5. Execute os métodos @After na superclasse

JUnit Nota de 5: essas anotações são JUnit 4 (org.junit). JUnit 5 renomearam-nos em org.junit.jupiter.api, e a JUnit O código 4 abaixo ainda funciona no motor antigo.

Exemplo: Criando uma classe com um arquivo como um ambiente de teste.

public class OutputFileTest		
{
    private File output; 
    @Before	public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

No exemplo acima, a cadeia de execução será a seguinte. O diagrama tracé um ciclo de criação-teste-exclusão por método de teste.

1. criarArquivoSaída()
2. arquivoteste1()
3. deleteOutputFile()
4. criarArquivoSaída()
5. arquivoteste2()
6. deleteOutputFile()

Suposição:

testFile1() é executado antes de testFile2(), o que não é garantido.

Configuração única

• É possível executar um método apenas uma vez para toda a classe de teste antes de qualquer teste ser executado e antes de qualquer teste. @Antes métodos).
• A configuração única é útil para iniciar servidores, estabelecer comunicações e tarefas semelhantes. Fechar e reabrir recursos para cada teste consome muito tempo.
• Isso pode ser feito usando a anotação @Antes da aula in JUnit.

@BeforeClass public static void Method_Name() {	
    // class setup code here	
 }	

O método deve ser vazio estático público, Porque JUnit Ele é chamado antes mesmo de qualquer instância de teste existir.

Desmontar uma única vez

• Semelhante à configuração única, um método de limpeza único também está disponível. Ele é executado após todos os métodos de caso de teste e @Depois de anotações foram executadas.
• É útil para pararping servidores e fechamento de links de comunicação.
• Isso pode ser feito usando o @Depois da aula anotação.

 @AfterClass public static void Method_Name()	
 {	
    // class cleanup code here	
 }	

JUnit Suites de teste

Com os cronogramas definidos, as turmas de teste relacionadas geralmente são agrupadas e lançadas juntas.

Se quisermos executar vários testes em uma ordem específica, podemos combinar todos os testes em um só lugar. Esse lugar é chamado de suíte de testes. Mais detalhes sobre como executar suítes de testes e como elas são usadas podem ser encontrados em [link para a documentação]. JUnit estão incluídos neste tutorial.

JUnit Corredor de Teste

JUnit fornece uma ferramenta para execução de seus casos de teste.

• JUnitSetores de class é usada para executar esses testes.
• Um método chamado runClasses fornecido por org.junit.runner.JUnitSetores de é usado para executar uma ou várias classes de teste.
• O tipo de retorno deste método é o Resultado objeto (org.junit.runner.Result), que é usado para acessar informações sobre os testes. Veja o exemplo de código a seguir para maior clareza.

public class Test {				
			public static void main(String[] args) {									
       		Result result = JUnitCore.runClasses(CreateAndSetName.class);					
			for (Failure failure : result.getFailures()) {							
         		System.out.println(failure.toString());					
      }		
      System.out.println(result.wasSuccessful());					
   }		
}      

No código acima, o objeto "result" é processado para obter as falhas e os sucessos dos casos de teste que estamos executando. Funções auxiliares como assertEquals levantar essas falhas, enquanto @Ignorar falta a um teste.

JUnit Nota de 5: JUnitSetores de é o JUnit 4 corredores. JUnit 5 o substitui pelo JUnit Plataforma lançador API, normalmente iniciada pela IDE, Gradle ou Maven Surefire.

Primeiro nome JUnit Programa

Conhecimento razoável do ciclo de vida de desenvolvimento de software (SDLC). Java programação e os fundamentos da teste de software O processo ajuda a compreender um JUnit programa, assim como saber como testes de unidade diferem dos testes de integração.

Vamos entender os testes unitários usando um exemplo prático. Precisamos criar uma classe de teste com um método de teste anotado com @Teste conforme dado abaixo:

MyFirstClassTest.java

package guru99.JUnit;		

import static org.junit.Assert.*;				

import org.junit.Test;		

public class MyFirstClassTest {				

    @Test		
    public void myFirstMethod(){					
        String str= "JUnit is working fine";					
        assertEquals("JUnit is working fine",str);					
    }
}		

TestRunner.java

Para executar nosso método de teste (acima), precisamos criar um executor de testes. No executor de testes, precisamos adicionar a classe de teste como um parâmetro em JUnitO método runClasses() do Core retornará o resultado do teste, indicando se ele foi aprovado ou reprovado.

Para obter mais detalhes sobre isso, consulte o código abaixo:

package guru99.JUnit;		

import org.junit.runner.JUnitCore;		
import org.junit.runner.Result;		
import org.junit.runner.notification.Failure;		

public class TestRunner {				
			public static void main(String[] args) {									
            Result result = JUnitCore.runClasses(MyFirstClassTest.class);					
			for (Failure failure : result.getFailures()) {							
              System.out.println(failure.toString());					
      }		
      System.out.println("Result=="+result.wasSuccessful());							
   }		
}      	

saída

Uma vez TestRunner.java Ao executarmos nossos métodos de teste, obtemos como resultado "falha" ou "aprovado". Veja abaixo a explicação do resultado:

1. Neste exemplo, depois de executar MyFirstClassTest.javaO teste foi aprovado e o resultado é verde.
2. Se tivesse falhado, o resultado teria sido exibido em vermelho, e a falha pode ser observada na falha. trace. Veja o JUnit Interface gráfica abaixo:

Perguntas Frequentes