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

JUnit é a unidade mais popular ensaio estrutura em Java. É explicitamente recomendado para Teste de Unidade. JUnit não requer servidor para testar aplicativos web, o que torna o processo de teste rápido.

A estrutura JUnit 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 muitas interfaces e classes para testes JUnit, como Test, Assert, After, Before, etc.

O que é dispositivo de teste

Antes de entendermos o que é um acessório de teste, 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 é complex 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 é uma 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/recursos.
  • Essas atividades são
    1. alocação (instalação)
    2. desalocação (teardown).

Configuração e desmontagem

  • 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 ajudam na configuração e desmontagem. Ele garante que os recursos sejam liberados e que o sistema de teste esteja pronto para o próximo caso de teste.

Essas anotações JUnit são discutidas abaixo-

instalação

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

Desmontagem (independentemente do veredicto)

@Depois de a anotação é usada em um método que contém código java para 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 no caso de falhas de asserção.

Nota:

  • É permitido ter qualquer número de anotações listadas acima.
  • Todos os métodos anotados com @Antes no JUnit serão executados antes de cada caso de teste, mas podem ser executados em qualquer ordem.
  • Você pode herdar os métodos @Before e @After de uma superclasse. A execução é a seguinte: É um processo de execução padrão no JUnit.
  1. Execute os métodos JUnit @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

Exemplo: Criando uma classe com arquivo como acessório 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:

Configuração e desmontagem

  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, abrir comunicações, etc. É demorado fechar e reabrir recursos para cada teste.
  • Isso pode ser feito usando a anotação @Antes da aula em JUnit.
@BeforeClass public static void Method_Name() {	
    // class setup code here	
 }	

Desmontar uma única vez

  • Semelhante à configuração única, um método de limpeza única 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 parar servidores, fechar links de comunicação, etc.
  • Isso pode ser feito usando o @Depois da aula anotação
 @AfterClass public static void Method_Name()	
 {	
    // class cleanup code here	
 }	

Conjuntos de testes JUnit

Se quisermos executar vários testes em uma ordem especificada, isso pode ser feito combinando todos os testes em um só lugar. Este lugar é chamado de suítes de teste. Mais details sobre como executar suítes de testes e como ele é usado no JUnit será abordado neste tutorial.

Executor de testes Junit

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

  • JUnitCore class é usada para executar esses testes.
  • Um método chamado runClasses fornecido por org.junit.runner.JUnitCore, é 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 é utilizado para acessar informações sobre os testes. Veja a seguirwing exemplo de código 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 “resultado” é processado para obter falhas e resultados bem-sucedidos dos casos de teste que estamos executando.

Primeiro programa JUnit

Conhecimento razoável de SDLC, programação java e noções básicas de teste de software processo ajuda na compreensão do programa JUnit.

Vamos entender o teste unitário usando um exemplo ao vivo. 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 teste. No executor de teste, temos que adicionar a classe de teste como parâmetro no método runclasses() do JUnitCore. Ele retornará o resultado do teste, com base na aprovação ou reprovação do teste.

Para mais details sobre isso veja 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 executa nossos métodos de teste, obtemos a saída como reprovada ou aprovada. Encontre abaixo a explicação da saída:

  1. Neste exemplo, depois de executar MyFirstClassTest.java , o teste foi aprovado e o resultado está em verde.
  2. Se tivesse falhado, deveria ter mostrado o resultado em Vermelho e a falha pode ser observada no rastreamento de falha. Veja abaixo JUnit gui:

Saída do programa JUnit

Resumo

  • JUnit é um framework que suporta diversas anotações para identificar um método que contém um teste.
  • JUnit fornece uma anotação chamada @Teste, que informa ao JUnit que o método public void no qual é usado pode ser executado como um caso de teste.
  • Um acessório de teste é um contexto onde um caso de teste é executado
  • Para executar vários testes em uma ordem especificada, isso pode ser feito combinando todos os testes em um só lugar. Este lugar é chamado de suítes de teste.
  • JUnit fornece uma ferramenta para execução de testes onde podemos executar nossos casos de teste denominado Test Runner.