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

Por: Thomas Hamilton Thomas Hamilton
Hours Atualização do

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

JUnit framework também permite a geração rápida e fácil de casos de teste e dados de teste. O org.Junit pacote consiste em muitas interfaces e classes para JUnit Testes 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 é 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 é 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.

Este JUnit 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 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 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: É 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

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 in 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	
 }

JUnit Suites de teste

Se quisermos executar vários testes em uma ordem específica, isso pode ser feito combinando todos os testes em um só lugar. Esse lugar é chamado de suítes de teste. Mais detalhes sobre como executar suítes de teste e como elas são usadas em JUnit será abordado neste tutorial.

Executor de testes Junit

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

  • JUnitnúcleo class é usada para executar esses testes.
  • Um método chamado runClasses fornecido por org.junit.runner.JUnitTestemunho, é 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. Consulte o exemplo de código a seguir para obter mais 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 nome JUnit programa

Conhecimento razoável de SDLC, programação java e noções básicas de teste de software processo ajuda na compreensão 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 em JUnitMétodo runclasses() do Core. Ele retornará o resultado do teste, com base na aprovação ou reprovação do teste.

Para mais detalhes 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:

JUnit Saída do programa

Resumo

  • JUnit é uma estrutura que suporta diversas anotações para identificar um método que contém um teste.
  • JUnit fornece uma anotação chamada @Teste, que diz ao JUnit que o método public void no qual ele é usado possa 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 dos testes onde podemos executar nossos casos de teste denominado Test Runner.

Você pode gostar: