JUnit - Guia rápido

Teste é o processo de verificar a funcionalidade de um aplicativo para garantir que ele seja executado de acordo com os requisitos. O teste de unidade surge no nível dos desenvolvedores; é o teste de uma única entidade (classe ou método). O teste de unidade desempenha um papel crítico em ajudar uma empresa de software a entregar produtos de qualidade a seus clientes.

O teste de unidade pode ser feito de duas maneiras - teste manual e teste automatizado.

Teste Manual	Teste Automatizado
Executar casos de teste manualmente sem qualquer suporte de ferramenta é conhecido como teste manual.	Obter suporte de ferramenta e executar os casos de teste usando uma ferramenta de automação é conhecido como teste de automação.
Time-consuming and tedious - Como os casos de teste são executados por recursos humanos, é muito lento e tedioso.	Fast - A automação executa casos de teste significativamente mais rápido do que recursos humanos.
Huge investment in human resources - Como os casos de teste precisam ser executados manualmente, mais testadores são necessários no teste manual.	Less investment in human resources - Casos de teste são executados usando ferramentas de automação, portanto, menos número de testadores são necessários nos testes de automação.
Less reliable - O teste manual é menos confiável, pois leva em consideração os erros humanos.	More reliable - Os testes de automação são precisos e confiáveis.
Non-programmable - Nenhuma programação pode ser feita para escrever testes sofisticados para buscar informações ocultas.	Programmable - Os testadores podem programar testes sofisticados para revelar informações ocultas.

O que é JUnit?

JUnit é uma estrutura de teste de unidade para a linguagem de programação Java. Ele desempenha um papel crucial no desenvolvimento orientado a testes e é uma família de estruturas de teste de unidade conhecidas coletivamente como xUnit.

JUnit promove a ideia de "primeiro testar e depois codificar", que enfatiza a configuração dos dados de teste para um trecho de código que pode ser testado primeiro e depois implementado. Essa abordagem é como "teste um pouco, codifique um pouco, teste um pouco, codifique um pouco". Ele aumenta a produtividade do programador e a estabilidade do código do programa, o que, por sua vez, reduz o estresse do programador e o tempo gasto na depuração.

Recursos do JUnit

JUnit é uma estrutura de código aberto, usada para escrever e executar testes.
Fornece anotações para identificar métodos de teste.
Fornece afirmações para testar os resultados esperados.
Fornece executores de teste para testes em execução.
Os testes JUnit permitem escrever códigos mais rapidamente, o que aumenta a qualidade.
JUnit é elegantemente simples. É menos complexo e leva menos tempo.
Os testes JUnit podem ser executados automaticamente e eles verificam seus próprios resultados e fornecem feedback imediato. Não há necessidade de vasculhar manualmente um relatório de resultados de teste.
Os testes JUnit podem ser organizados em suítes de teste contendo casos de teste e até mesmo outras suítes de teste.
O JUnit mostra o andamento do teste em uma barra que fica verde se o teste está funcionando sem problemas e fica vermelha quando um teste falha.

O que é um caso de teste de unidade?

Um Caso de Teste de Unidade é uma parte do código, o que garante que outra parte do código (método) funcione conforme o esperado. Para alcançar os resultados desejados rapidamente, uma estrutura de teste é necessária. JUnit é uma estrutura de teste de unidade perfeita para a linguagem de programação Java.

Um caso de teste de unidade formal escrito é caracterizado por uma entrada conhecida e uma saída esperada, que é elaborada antes da execução do teste. A entrada conhecida deve testar uma pré-condição e a saída esperada deve testar uma pós-condição.

Deve haver pelo menos dois casos de teste de unidade para cada requisito - um teste positivo e um teste negativo. Se um requisito tiver sub-requisitos, cada sub-requisito deve ter pelo menos dois casos de teste como positivos e negativos.

Configuração de ambiente local

JUnit é uma estrutura para Java, portanto, o primeiro requisito é ter o JDK instalado em sua máquina.

Requisitos do sistema

JDK	1,5 ou superior.
Memória	Sem requisitos mínimos.
Espaço em disco	Sem requisitos mínimos.
Sistema operacional	Sem requisitos mínimos.

Etapa 1: verifique a instalação do Java em sua máquina

Em primeiro lugar, abra o console e execute um comando java baseado no sistema operacional em que está trabalhando.

SO	Tarefa	Comando
janelas	Abrir console de comando	c: \> versão java
Linux	Abra o terminal de comando	$ java -version
Mac	Terminal aberto	máquina: ~ joseph $ java -version

Vamos verificar a saída de todos os sistemas operacionais -

SO	Resultado
janelas	versão java "1.8.0_101" Java (TM) SE Runtime Environment (build 1.8.0_101)
Linux	versão java "1.8.0_101" Java (TM) SE Runtime Environment (build 1.8.0_101)
Mac	versão java "1.8.0_101" Java (TM) SE Runtime Environment (build 1.8.0_101)

Se você não tiver o Java instalado em seu sistema, baixe o Java Software Development Kit (SDK) do seguinte link https://www.oracle.com. Estamos assumindo o Java 1.8.0_101 como a versão instalada para este tutorial.

Etapa 2: definir o ambiente JAVA

Colocou o JAVA_HOMEvariável de ambiente para apontar para o local do diretório base onde o Java está instalado em sua máquina. Por exemplo.

SO	Resultado
janelas	Defina a variável de ambiente JAVA_HOME para C: \ Program Files \ Java \ jdk1.8.0_101
Linux	export JAVA_HOME = / usr / local / java-current
Mac	export JAVA_HOME = / Library / Java / Home

Anexe a localização do compilador Java ao caminho do sistema.

SO	Resultado
janelas	Anexar a string C:\Program Files\Java\jdk1.8.0_101\bin no final da variável do sistema, Path.
Linux	exportar PATH = $PATH:$JAVA_HOME / bin /
Mac	não requerido

Verifique a instalação do Java usando o comando java -version conforme explicado acima.

Etapa 3: Baixe o arquivo JUnit

Baixe a versão mais recente do arquivo JUnit jar em http://www.junit.org. No momento de escrever este tutorial, baixamos Junit-4.12.jar e o copiamos para a pasta C: \> JUnit.

SO	Nome do arquivo
janelas	junit4.12.jar
Linux	junit4.12.jar
Mac	junit4.12.jar

Etapa 4: definir o ambiente JUnit

Colocou o JUNIT_HOMEvariável de ambiente para apontar para o local do diretório base onde o jar JUNIT está armazenado em sua máquina. Vamos supor que armazenamos junit4.12.jar na pasta JUNIT.

Sr. Não	SO e descrição
1	Windows Defina a variável de ambiente JUNIT_HOME para C: \ JUNIT
2	Linux export JUNIT_HOME = / usr / local / JUNIT
3	Mac export JUNIT_HOME = / Biblioteca / JUNIT

Etapa 5: definir a variável CLASSPATH

Colocou o CLASSPATH variável de ambiente para apontar para a localização do jar JUNIT.

Sr. Não	SO e descrição
1	Windows Defina a variável de ambiente CLASSPATH como% CLASSPATH%;% JUNIT_HOME% \ junit4.12.jar;.;
2	Linux export CLASSPATH = $CLASSPATH:$JUNIT_HOME / junit4.12.jar :.
3	Mac export CLASSPATH = $CLASSPATH:$JUNIT_HOME / junit4.12.jar :.

Etapa 6: teste a configuração do JUnit

Crie um arquivo de classe java com o nome TestJunit em C:\>JUNIT_WORKSPACE

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class TestJunit {
   @Test
	
   public void testAdd() {
      String str = "Junit is working fine";
      assertEquals("Junit is working fine",str);
   }
}

Crie um arquivo de classe java com o nome TestRunner em C:\>JUNIT_WORKSPACE para executar caso (s) de teste.

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Etapa 7: verificar o resultado

Compile as classes usando javac compilador da seguinte forma -

C:\JUNIT_WORKSPACE>javac TestJunit.java TestRunner.java

Agora execute o Test Runner para ver o resultado da seguinte forma -

C:\JUNIT_WORKSPACE>java TestRunner

Verifique a saída.

true

JUnit é um Regression Testing Frameworkusado por desenvolvedores para implementar testes de unidade em Java e acelerar a velocidade de programação e aumentar a qualidade do código. O JUnit Framework pode ser facilmente integrado com qualquer um dos seguintes -

Eclipse
Ant
Maven

Recursos do JUnit Test Framework

A estrutura de teste JUnit fornece os seguintes recursos importantes -

Fixtures
Suítes de teste
Corredores de teste
Classes JUnit

Luminárias

Fixturesé um estado fixo de um conjunto de objetos usados como linha de base para a execução de testes. O objetivo de um dispositivo de teste é garantir que haja um ambiente bem conhecido e fixo no qual os testes são executados para que os resultados sejam repetidos. Inclui -

método setUp (), que é executado antes de cada invocação de teste.
método tearDown (), que é executado após cada método de teste.

Vamos verificar um exemplo -

import junit.framework.*;

public class JavaTest extends TestCase {
   protected int value1, value2;
   
   // assigning the values
   protected void setUp(){
      value1 = 3;
      value2 = 3;
   }

   // test method to add two values
   public void testAdd(){
      double result = value1 + value2;
      assertTrue(result == 6);
   }
}

Suites de teste

Um conjunto de testes agrupa alguns casos de teste de unidade e os executa juntos. No JUnit, as anotações @RunWith e @Suite são usadas para executar o teste do conjunto. Abaixo está um exemplo que usa as classes de teste TestJunit1 e TestJunit2.

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

//JUnit Suite Test
@RunWith(Suite.class)

@Suite.SuiteClasses({ 
   TestJunit1.class ,TestJunit2.class
})

public class JunitTestSuite {
}

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit1 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");    
      assertEquals(message, messageUtil.printMessage());     
   }
}

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit2 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
 
   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Executores de teste

O executor de teste é usado para executar os casos de teste. Aqui está um exemplo que assume a classe de testeTestJunit já existe.

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Classes JUnit

As classes JUnit são classes importantes, usadas para escrever e testar JUnits. Algumas das classes importantes são -

Assert - Contém um conjunto de métodos de declaração.
TestCase - Contém um caso de teste que define o aparelho para executar vários testes.
TestResult - Contém métodos para coletar os resultados da execução de um caso de teste.

Vamos agora ter um exemplo básico para demonstrar o processo passo a passo de usar JUnit.

Criar uma aula

Crie uma classe java a ser testada, digamos, MessageUtil.java em C:\>JUNIT_WORKSPACE

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
	
   public MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   
}

Criar classe de caso de teste

Crie uma classe de teste java, digamos, TestJunit.java.
Adicione um método de teste testPrintMessage () à sua classe de teste.
Adicione um Annotaion @Test ao método testPrintMessage ().
Implemente a condição de teste e verifique a condição usando a API assertEquals do JUnit.

Crie um arquivo de classe java com o nome TestJunit.java em C:\>JUNIT_WORKSPACE.

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      assertEquals(message,messageUtil.printMessage());
   }
}

Criar classe de executor de teste

Crie uma classe Java TestRunner.
Use o método runClasses da classe JUnitCore de JUnit para executar o caso de teste da classe de teste criada acima.
Obtenha o resultado dos casos de teste executados no Objeto Result.
Obtenha falha (s) usando o método getFailures () do objeto Result.
Obtenha o resultado de Sucesso usando o método wasSuccessful () do objeto Result.

Crie um arquivo de classe java chamado TestRunner.java em C:\>JUNIT_WORKSPACE para executar caso (s) de teste.

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile as classes MessageUtil, Test case e Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Agora execute o Test Runner, que executará o caso de teste definido na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique a saída.

Hello World
true

Agora atualize TestJunit em C:\>JUNIT_WORKSPACEpara que o teste falhe. Altere a string da mensagem.

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      message = "New Word";
      assertEquals(message,messageUtil.printMessage());
   }
}

Vamos manter o resto das classes como estão e tentar executar o mesmo Test Runner.

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Agora execute o Test Runner, que executará o caso de teste definido na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique a saída.

Hello World
testPrintMessage(TestJunit): expected:<[New Wor]d> but was:<[Hello Worl]d>
false

O pacote mais importante no JUnit é junit.framework, que contém todas as classes principais. Algumas das classes importantes são as seguintes -

Sr. Não.	Nome da classe	Funcionalidade
1	Afirmar	Um conjunto de métodos de declaração.
2	Caso de teste	Um caso de teste define o dispositivo para executar vários testes.
3	Resultado do teste	Um TestResult coleta os resultados da execução de um caso de teste.
4	Suíte de teste	Um TestSuite é um composto de testes.

Classe Assert

A seguir está a declaração para org.junit.Assert classe -

public class Assert extends java.lang.Object

Esta classe fornece um conjunto de métodos de asserção úteis para escrever testes. Apenas as afirmações com falha são registradas. Alguns dos métodos importantes da classe Assert são os seguintes -

Sr. Não.	Métodos e Descrição
1	void assertEquals(boolean expected, boolean actual) Verifica se dois primitivos / objetos são iguais.
2	void assertFalse(boolean condition) Verifica se uma condição é falsa.
3	void assertNotNull(Object object) Verifica se um objeto não é nulo.
4	void assertNull(Object object) Verifica se um objeto é nulo.
5	void assertTrue(boolean condition) Verifica se uma condição é verdadeira.
6	void fail() Falha em um teste sem mensagem.

Vamos usar alguns dos métodos mencionados acima em um exemplo. Crie um arquivo de classe java chamado TestJunit1.java emC:\>JUNIT_WORKSPACE.

import org.junit.Test;
import static org.junit.Assert.*;

public class TestJunit1 {
   @Test
   public void testAdd() {
      //test data
      int num = 5;
      String temp = null;
      String str = "Junit is working fine";

      //check for equality
      assertEquals("Junit is working fine", str);
      
      //check for false condition
      assertFalse(num > 6);

      //check for not null value
      assertNotNull(temp);
   }
}

Em seguida, crie um arquivo de classe java chamado TestRunner1.java em C: \> JUNIT_WORKSPACE para executar caso (s) de teste.

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

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

Compile o caso de teste e as classes Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac TestJunit1.java TestRunner1.java

Agora execute o Test Runner, que executará o caso de teste definido na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner1

Verifique a saída.

true

Classe TestCase

A seguir está a declaração para org.junit.TestCase classe -

public abstract class TestCase extends Assert implements Test

Um caso de teste define o dispositivo para executar vários testes. Alguns dos métodos importantes deTestCase classe são as seguintes -

Sr. Não.	Métodos e Descrição
1	int countTestCases() Conta o número de casos de teste executados por execução (resultado do TestResult).
2	TestResult createResult() Cria um objeto TestResult padrão.
3	String getName() Obtém o nome de um TestCase.
4	TestResult run() Um método conveniente para executar este teste, coletando os resultados com um objeto TestResult padrão.
5	void run(TestResult result) Executa o caso de teste e coleta os resultados em TestResult.
6	void setName(String name) Define o nome de um TestCase.
7	void setUp() Configura o aparelho, por exemplo, abre uma conexão de rede.
8	void tearDown() Derruba o aparelho, por exemplo, fecha uma conexão de rede.
9	String toString() Retorna uma representação de string do caso de teste.

Vamos usar alguns dos métodos mencionados acima em um exemplo. Crie um arquivo de classe java chamadoTestJunit2.java em C: \> JUNIT_WORKSPACE.

import junit.framework.TestCase;
import org.junit.Before;
import org.junit.Test;

public class TestJunit2 extends TestCase  {
   protected double fValue1;
   protected double fValue2;
   
   @Before 
   public void setUp() {
      fValue1 = 2.0;
      fValue2 = 3.0;
   }
	
   @Test
   public void testAdd() {
      //count the number of test cases
      System.out.println("No of Test Case = "+ this.countTestCases());
		
      //test getName 
      String name = this.getName();
      System.out.println("Test Case Name = "+ name);

      //test setName
      this.setName("testNewAdd");
      String newName = this.getName();
      System.out.println("Updated Test Case Name = "+ newName);
   }
	
   //tearDown used to close the connection or clean up activities
   public void tearDown(  ) {
   }
}

Em seguida, crie um arquivo de classe java chamado TestRunner2.java em C: \> JUNIT_WORKSPACE para executar caso (s) de teste.

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

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

Compile o caso de teste e as classes Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac TestJunit2.java TestRunner2.java

Agora execute o Test Runner, que executará o caso de teste definido na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner2

Verifique a saída.

No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
true

Classe TestResult

A seguir está a declaração para org.junit.TestResult classe -

public class TestResult extends Object

Um TestResult coleta os resultados da execução de um caso de teste. É uma instância do padrão de parâmetro de coleta. A estrutura de teste distingue entre falhas e erros. Uma falha é antecipada e verificada com afirmações. Erros são problemas imprevistos, como uma ArrayIndexOutOfBoundsException. Alguns dos métodos importantes deTestResult classe são as seguintes -

Sr. Não.	Métodos e Descrição
1	void addError(Test test, Throwable t) Adiciona um erro à lista de erros.
2	void addFailure(Test test, AssertionFailedError t) Adiciona uma falha à lista de falhas.
3	void endTest(Test test) Informa o resultado de que um teste foi concluído.
4	int errorCount() Obtém o número de erros detectados.
5	Enumeration<TestFailure> errors() Retorna uma Enumeração para os erros.
6	int failureCount() Obtém o número de falhas detectadas.
7	void run(TestCase test) Executa um TestCase.
8	int runCount() Obtém o número de testes de execução.
9	void startTest(Test test) Informa o resultado de que um teste será iniciado.
10	void stop() Marca que a execução do teste deve parar.

Crie um arquivo de classe java chamado TestJunit3.java em C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import junit.framework.AssertionFailedError;
import junit.framework.TestResult;

public class TestJunit3 extends TestResult {
   // add the error
   public synchronized void addError(Test test, Throwable t) {
      super.addError((junit.framework.Test) test, t);
   }

   // add the failure
   public synchronized void addFailure(Test test, AssertionFailedError t) {
      super.addFailure((junit.framework.Test) test, t);
   }
	
   @Test
   public void testAdd() {
      // add any test
   }
   
   // Marks that the test run should stop.
   public synchronized void stop() {
      //stop the test here
   }
}

Em seguida, crie um arquivo de classe java chamado TestRunner3.java em C: \> JUNIT_WORKSPACE para executar caso (s) de teste.

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

public class TestRunner3 {
   public static void main(String[] args) {
      Result result = JUnitCore.runClasses(TestJunit3.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile o caso de teste e as classes Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac TestJunit3.java TestRunner3.java

Agora execute o Test Runner, que executará o caso de teste definido na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner3

Verifique a saída.

true

Classe TestSuite

A seguir está a declaração para org.junit.TestSuite classe:

public class TestSuite extends Object implements Test

Um TestSuite é um composto de testes. Ele executa uma coleção de casos de teste. Alguns dos métodos importantes deTestSuite classe são as seguintes -

Sr. Não.	Métodos e Descrição
1	void addTest(Test test) Adiciona um teste ao conjunto.
2	void addTestSuite(Class<? extends TestCase> testClass) Adiciona os testes da classe dada ao conjunto.
3	int countTestCases() Conta o número de casos de teste que serão executados por este teste.
4	String getName() Retorna o nome da suíte.
5	void run(TestResult result) Executa os testes e coleta seu resultado em um TestResult.
6	void setName(String name) Define o nome da suíte.
7	Test testAt(int index) Retorna o teste no índice fornecido.
8	int testCount() Retorna o número de testes neste conjunto.
9	static Test warning(String message) Retorna um teste que falhará e registrará uma mensagem de aviso.

Crie um arquivo de classe java chamado JunitTestSuite.java em C: \> JUNIT_WORKSPACE para criar o conjunto de testes.

import junit.framework.*;

public class JunitTestSuite {
   public static void main(String[] a) {
      // add the test's in the suite
      TestSuite suite = new TestSuite(TestJunit1.class, TestJunit2.class, TestJunit3.class );
      TestResult result = new TestResult();
      suite.run(result);
      System.out.println("Number of test cases = " + result.runCount());
   }
}

Compile as classes do conjunto de testes usando javac.

C:\JUNIT_WORKSPACE>javac JunitTestSuite.java

Agora execute o Test Suite.

C:\JUNIT_WORKSPACE>java JunitTestSuite

Verifique a saída.

No of Test Case = 1
Test Case Name = testAdd
Updated Test Case Name = testNewAdd
Number of test cases = 3

Aqui, veremos um exemplo completo de teste JUnit usando a classe POJO, a classe de lógica de negócios e uma classe de teste, que será executada pelo executor de teste.

Crio EmployeeDetails.java em C: \> JUNIT_WORKSPACE, que é uma classe POJO.

public class EmployeeDetails {

   private String name;
   private double monthlySalary;
   private int age;
   
   /**
   * @return the name
   */
	
   public String getName() {
      return name;
   }
	
   /**
   * @param name the name to set
   */
	
   public void setName(String name) {
      this.name = name;
   }
	
   /**
   * @return the monthlySalary
   */
	
   public double getMonthlySalary() {
      return monthlySalary;
   }
	
   /**
   * @param monthlySalary the monthlySalary to set
   */
	
   public void setMonthlySalary(double monthlySalary) {
      this.monthlySalary = monthlySalary;
   }
	
   /**
   * @return the age
   */
   public int getAge() {
      return age;
   }
	
   /**
   * @param age the age to set
   */
   public void setAge(int age) {
      this.age = age;
   }
}

EmployeeDetails classe é usada para -

obter / definir o valor do nome do funcionário.
obter / definir o valor do salário mensal do funcionário.
obter / definir o valor da idade do funcionário.

Crie um arquivo chamado EmpBusinessLogic.java em C: \> JUNIT_WORKSPACE, que contém a lógica de negócios.

public class EmpBusinessLogic {
   // Calculate the yearly salary of employee
   public double calculateYearlySalary(EmployeeDetails employeeDetails) {
      double yearlySalary = 0;
      yearlySalary = employeeDetails.getMonthlySalary() * 12;
      return yearlySalary;
   }
	
   // Calculate the appraisal amount of employee
   public double calculateAppraisal(EmployeeDetails employeeDetails) {
      double appraisal = 0;
		
      if(employeeDetails.getMonthlySalary() < 10000){
         appraisal = 500;
      }else{
         appraisal = 1000;
      }
		
      return appraisal;
   }
}

EmpBusinessLogic classe é usada para calcular -

o salário anual de um empregado.
o valor de avaliação de um funcionário.

Crie um arquivo chamado TestEmployeeDetails.java em C: \> JUNIT_WORKSPACE, que contém os casos de teste a serem testados.

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class TestEmployeeDetails {
   EmpBusinessLogic empBusinessLogic = new EmpBusinessLogic();
   EmployeeDetails employee = new EmployeeDetails();

   //test to check appraisal
   @Test
   public void testCalculateAppriasal() {
      employee.setName("Rajeev");
      employee.setAge(25);
      employee.setMonthlySalary(8000);
		
      double appraisal = empBusinessLogic.calculateAppraisal(employee);
      assertEquals(500, appraisal, 0.0);
   }

   // test to check yearly salary
   @Test
   public void testCalculateYearlySalary() {
      employee.setName("Rajeev");
      employee.setAge(25);
      employee.setMonthlySalary(8000);
		
      double salary = empBusinessLogic.calculateYearlySalary(employee);
      assertEquals(96000, salary, 0.0);
   }
}

TestEmployeeDetails classe é usada para testar os métodos de EmpBusinessLogicclasse. isto

testa o salário anual do funcionário.
testa o valor de avaliação do funcionário.

Em seguida, crie um arquivo de classe java chamado TestRunner.java em C: \> JUNIT_WORKSPACE para executar caso (s) de teste.

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(TestEmployeeDetails.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile o caso de teste e as classes Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac EmployeeDetails.java 
EmpBusinessLogic.java TestEmployeeDetails.java TestRunner.java

Agora execute o Test Runner, que executará o caso de teste definido na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique a saída.

true

Afirmação

Todas as asserções estão na classe Assert.

public class Assert extends java.lang.Object

Esta classe fornece um conjunto de métodos de asserção, úteis para escrever testes. Apenas as afirmações com falha são registradas. Alguns dos métodos importantes da classe Assert são os seguintes -

Sr. Não.	Métodos e Descrição
1	void assertEquals(boolean expected, boolean actual) Verifica se dois primitivos / objetos são iguais.
2	void assertTrue(boolean condition) Verifica se uma condição é verdadeira.
3	void assertFalse(boolean condition) Verifica se uma condição é falsa.
4	void assertNotNull(Object object) Verifica se um objeto não é nulo.
5	void assertNull(Object object) Verifica se um objeto é nulo.
6	void assertSame(object1, object2) O método assertSame () testa se duas referências de objeto apontam para o mesmo objeto.
7	void assertNotSame(object1, object2) O método assertNotSame () testa se duas referências de objeto não apontam para o mesmo objeto.
8	void assertArrayEquals(expectedArray, resultArray); O método assertArrayEquals () testará se dois arrays são iguais.

Vamos usar alguns dos métodos mencionados acima em um exemplo. Crie um arquivo de classe java chamadoTestAssertions.java em C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import static org.junit.Assert.*;

public class TestAssertions {

   @Test
   public void testAssertions() {
      //test data
      String str1 = new String ("abc");
      String str2 = new String ("abc");
      String str3 = null;
      String str4 = "abc";
      String str5 = "abc";
		
      int val1 = 5;
      int val2 = 6;

      String[] expectedArray = {"one", "two", "three"};
      String[] resultArray =  {"one", "two", "three"};

      //Check that two objects are equal
      assertEquals(str1, str2);

      //Check that a condition is true
      assertTrue (val1 < val2);

      //Check that a condition is false
      assertFalse(val1 > val2);

      //Check that an object isn't null
      assertNotNull(str1);

      //Check that an object is null
      assertNull(str3);

      //Check if two object references point to the same object
      assertSame(str4,str5);

      //Check if two object references not point to the same object
      assertNotSame(str1,str3);

      //Check whether two arrays are equal to each other.
      assertArrayEquals(expectedArray, resultArray);
   }
}

Em seguida, crie um arquivo de classe java chamado TestRunner.java em C: \> JUNIT_WORKSPACE para executar caso (s) de teste.

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

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

Compile o caso de teste e as classes Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac TestAssertions.java TestRunner.java

Agora execute o Test Runner, que executará o caso de teste definido na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique a saída.

true

Anotação

As anotações são como metatags que você pode adicionar ao seu código e aplicá-las a métodos ou em classe. Essas anotações no JUnit fornecem as seguintes informações sobre os métodos de teste -

quais métodos serão executados antes e depois dos métodos de teste.
quais métodos são executados antes e depois de todos os métodos e.
quais métodos ou classes serão ignorados durante a execução.

A tabela a seguir fornece uma lista de anotações e seu significado no JUnit -

Sr. Não.	Anotação e descrição
1	@Test A anotação de teste informa ao JUnit que o método void público ao qual está anexado pode ser executado como um caso de teste.
2	@Before Vários testes precisam de objetos semelhantes criados antes de serem executados. Anotar um método void público com @Before faz com que esse método seja executado antes de cada método de teste.
3	@After Se você alocar recursos externos em um método Before, precisará liberá-los após a execução do teste. Anotar um método void público com @After faz com que esse método seja executado após o método Test.
4	@BeforeClass Anotar um método void estático público com @BeforeClass faz com que ele seja executado uma vez antes de qualquer um dos métodos de teste na classe.
5	@AfterClass Isso executará o método após a conclusão de todos os testes. Isso pode ser usado para realizar atividades de limpeza.
6	@Ignore A anotação Ignorar é usada para ignorar o teste e esse teste não será executado.

Crie um arquivo de classe java chamado JunitAnnotation.java em C: \> JUNIT_WORKSPACE para testar a anotação.

import org.junit.After;
import org.junit.AfterClass;

import org.junit.Before;
import org.junit.BeforeClass;

import org.junit.Ignore;
import org.junit.Test;

public class JunitAnnotation {
	
   //execute before class
   @BeforeClass
   public static void beforeClass() {
      System.out.println("in before class");
   }

   //execute after class
   @AfterClass
   public static void  afterClass() {
      System.out.println("in after class");
   }

   //execute before test
   @Before
   public void before() {
      System.out.println("in before");
   }
	
   //execute after test
   @After
   public void after() {
      System.out.println("in after");
   }
	
   //test case
   @Test
   public void test() {
      System.out.println("in test");
   }
	
   //test case ignore and will not execute
   @Ignore
   public void ignoreTest() {
      System.out.println("in ignore test");
   }
}

Em seguida, crie um arquivo de classe java chamado TestRunner.java em C: \> JUNIT_WORKSPACE para executar anotações.

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(JunitAnnotation.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile o caso de teste e as classes Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac JunitAnnotation.java TestRunner.java

Agora execute o Test Runner, que executará o caso de teste definido na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique a saída.

in before class
in before
in test
in after
in after class
true

Este capítulo explica o procedimento de execução de métodos em JUnit, que define a ordem dos métodos chamados. Discutido a seguir é o procedimento de execução dos métodos de API de teste JUnit com exemplo.

Crie um arquivo de classe java denominado ExecutionProcedureJunit.java em C: \> JUNIT_WORKSPACE para testar a anotação.

import org.junit.After;
import org.junit.AfterClass;

import org.junit.Before;
import org.junit.BeforeClass;

import org.junit.Ignore;
import org.junit.Test;

public class ExecutionProcedureJunit {
	
   //execute only once, in the starting 
   @BeforeClass
   public static void beforeClass() {
      System.out.println("in before class");
   }

   //execute only once, in the end
   @AfterClass
   public static void  afterClass() {
      System.out.println("in after class");
   }

   //execute for each test, before executing test
   @Before
   public void before() {
      System.out.println("in before");
   }
	
   //execute for each test, after executing test
   @After
   public void after() {
      System.out.println("in after");
   }
	
   //test case 1
   @Test
   public void testCase1() {
      System.out.println("in test case 1");
   }

   //test case 2
   @Test
   public void testCase2() {
      System.out.println("in test case 2");
   }
}

Em seguida, crie um arquivo de classe java chamado TestRunner.java em C: \> JUNIT_WORKSPACE para executar anotações.

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(ExecutionProcedureJunit.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile o caso de teste e as classes Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac ExecutionProcedureJunit.java TestRunner.java

Agora execute o Test Runner, que executará o caso de teste definido na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique a saída.

in before class
in before
in test case 1
in after
in before
in test case 2
in after
in after class

Veja a saída acima. O procedimento de execução é o seguinte -

Em primeiro lugar, o método beforeClass () executa apenas uma vez.
O método afterClass () é executado apenas uma vez.
O método before () executa para cada caso de teste, mas antes de executar o caso de teste.
O método after () é executado para cada caso de teste, mas após a execução do caso de teste.
Entre before () e after (), cada caso de teste é executado.

Os casos de teste são executados usando JUnitCoreclasse. JUnitCore é uma fachada para a execução de testes. Ele suporta a execução de testes JUnit 4, testes JUnit 3.8.x e misturas. Para executar testes na linha de comando, execute java org.junit.runner.JUnitCore <TestClass>. Para execuções de teste único, use o método estático runClasses (Class []).

A seguir está a declaração para org.junit.runner.JUnitCore classe:

public class JUnitCore extends java.lang.Object

Aqui veremos como executar os testes com a ajuda do JUnitCore.

Criar uma aula

Crie uma classe java a ser testada, digamos, MessageUtil.java, em C: \> JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   
	
}

Criar classe de caso de teste

Crie uma classe de teste java, digamos, TestJunit.java.
Adicione um método de teste testPrintMessage () à sua classe de teste.
Adicione um Annotaion @Test ao método testPrintMessage ().
Implemente a condição de teste e verifique a condição usando a API assertEquals do JUnit.

Crie um arquivo de classe java chamado TestJunit.java em C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {
      assertEquals(message,messageUtil.printMessage());
   }
}

Criar classe de executor de teste

Agora crie um arquivo de classe java chamado TestRunner.javaem C: \> JUNIT_WORKSPACE para executar caso (s) de teste. Ele importa a classe JUnitCore e usa o método runClasses () que usa o nome da classe de teste como seu parâmetro.

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile o caso de teste e as classes Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Agora execute o Test Runner, que executará o caso de teste definido na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique a saída.

Hello World
true

Test suiteé usado para agrupar alguns casos de teste de unidade e executá-los juntos. No JUnit, ambos@RunWith e @Suiteas anotações são usadas para executar os testes do conjunto. Este capítulo dá um exemplo com duas classes de teste,TestJunit1 E TestJunit2, que são executados juntos usando o Test Suite.

Criar uma aula

Crie uma classe java a ser testada, digamos, MessageUtil.java em C: \> JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Criar classes de caso de teste

Crie um arquivo de classe java chamado TestJunit1.java em C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit1 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");    
      assertEquals(message, messageUtil.printMessage());     
   }
}

Crie um arquivo de classe java chamado TestJunit2.java em C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit2 {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
 
   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Criar classe de suíte de teste

Crie uma classe java.
Anexe a anotação @RunWith (Suite.class) com a classe.
Adicione referência às classes de teste JUnit usando a anotação @ Suite.SuiteClasses.

Crie um arquivo de classe java chamado TestSuite.java em C: \> JUNIT_WORKSPACE para executar caso (s) de teste.

import org.junit.runner.RunWith;
import org.junit.runners.Suite;

@RunWith(Suite.class)

@Suite.SuiteClasses({
   TestJunit1.class,
   TestJunit2.class
})

public class JunitTestSuite {   
}

Criar classe de executor de teste

Crie um arquivo de classe java chamado TestRunner.java em C: \> JUNIT_WORKSPACE para executar caso (s) de teste.

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(JunitTestSuite.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile todas as classes java usando javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit1.java 
TestJunit2.java JunitTestSuite.java TestRunner.java

Agora execute o Test Runner, que executará o caso de teste definido na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique a saída.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi Robert
true

Às vezes acontece que nosso código não está completamente pronto durante a execução de um caso de teste. Como resultado, o caso de teste falha. o@Ignore a anotação ajuda neste cenário.

Um método de teste anotado com @Ignore não será executado.
Se uma classe de teste for anotada com @Ignore, nenhum de seus métodos de teste será executado.

Agora vamos ver @Ignore em ação.

Criar uma aula

Crie uma classe java a ser testada, digamos, MessageUtil.java em C: \> JUNIT_WORKSPACE.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
	
}

Criar classe de caso de teste

Crie uma classe de teste java, digamos, TestJunit.java.
Adicione um método de teste testPrintMessage () ou testSalutationMessage () à sua classe de teste.
Adicione um Annotaion @Ignore ao método testPrintMessage ().

Crie um arquivo de classe java chamado TestJunit.java em C: \ JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Ignore
   @Test
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Robert";
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
	
}

Criar classe de executor de teste

Crie um arquivo de classe java chamado TestRunner.java em C: \> JUNIT_WORKSPACE para executar caso (s) de teste.

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(TestJunit.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile as classes MessageUtil, Test case e Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Agora execute o Test Runner, que não executará o caso de teste testPrintMessage () definido na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique a saída. O caso de teste testPrintMessage () não foi testado.

Inside testSalutationMessage()
Hi!Robert
true

Agora, atualize TestJunit em C: \> JUNIT_WORKSPACE para ignorar todos os casos de teste. Adicione @Ignore no nível da classe.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

@Ignore
public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
     
   @Test
   public void testPrintMessage() {
      System.out.println("Inside testPrintMessage()");
      message = "Robert";
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
	
}

Compile o caso de teste usando javac.

C:\JUNIT_WORKSPACE>javac TestJunit.java

Mantenha o seu Test Runner inalterado da seguinte maneira -

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Agora execute o Test Runner, que não executará nenhum caso de teste definido na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique a saída. Nenhum caso de teste é testado.

true

JUnit fornece uma opção útil de Timeout. Se um caso de teste levar mais tempo do que o número especificado de milissegundos, o JUnit o marcará automaticamente como falha. otimeoutparâmetro é usado junto com a anotação @Test. Vamos ver o @Test (tempo limite) em ação.

Criar uma aula

Crie uma classe java a ser testada, digamos, MessageUtil.java em C: \> JUNIT_WORKSPACE.

Adicione um loop while infinito dentro do método printMessage ().

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public void printMessage(){
      System.out.println(message);
      while(true);
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Criar classe de caso de teste

Crie uma classe de teste java, digamos, TestJunit.java. Adicione um tempo limite de 1000 ao caso de teste testPrintMessage ().

Crie um arquivo de classe java chamado TestJunit.java em C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test(timeout = 1000)
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      messageUtil.printMessage();     
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Criar classe de executor de teste

Crie um arquivo de classe java chamado TestRunner.java em C: \> JUNIT_WORKSPACE para executar caso (s) de teste.

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile as classes MessageUtil, Test case e Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Agora execute o Test Runner, que executará os casos de teste definidos na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique a saída. O caso de teste testPrintMessage () marcará o teste de unidade com falha.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi!Robert
testPrintMessage(TestJunit): test timed out after 1000 milliseconds
false

JUnit fornece uma opção de rastrear a manipulação de exceção do código. Você pode testar se o código lança uma exceção desejada ou não. oexpectedparâmetro é usado junto com a anotação @Test. Vamos ver @Test (esperado) em ação.

Criar uma aula

Crie uma classe java a ser testada, digamos, MessageUtil.java em C: \> JUNIT_WORKSPACE.

Adicione uma condição de erro dentro do método printMessage ().

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public void printMessage(){
      System.out.println(message);
      int a = 0;
      int b = 1/a;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Criar classe de caso de teste

Crie uma classe de teste java chamada TestJunit.java. Adicione uma exceção esperada ArithmeticException ao caso de teste testPrintMessage ().

Crie um arquivo de classe java chamado TestJunit.java em C: \> JUNIT_WORKSPACE.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestJunit {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test(expected = ArithmeticException.class)
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      messageUtil.printMessage();     
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Criar classe de executor de teste

Crie um arquivo de classe java chamado TestRunner.java em C: \> JUNIT_WORKSPACE para executar caso (s) de teste.

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(TestJunit.class);
		
      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile as classes MessageUtil, Test case e Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac MessageUtil.java TestJunit.java TestRunner.java

Agora execute o Test Runner, que executará os casos de teste definidos na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique a saída. O caso de teste testPrintMessage () será aprovado.

Inside testPrintMessage()
Robert
Inside testSalutationMessage()
Hi!Robert
true

JUnit 4 introduziu um novo recurso chamado parameterized tests. Os testes parametrizados permitem que um desenvolvedor execute o mesmo teste repetidamente usando valores diferentes. Existem cinco etapas que você precisa seguir para criar um teste parametrizado.

Anote a classe de teste com @RunWith (Parameterized.class).
Crie um método estático público anotado com @Parameters que retorna uma coleção de objetos (como matriz) como conjunto de dados de teste.
Crie um construtor público que obtenha o que é equivalente a uma "linha" de dados de teste.
Crie uma variável de instância para cada "coluna" de dados de teste.
Crie seu (s) caso (s) de teste usando as variáveis de instância como a fonte dos dados de teste.

O caso de teste será chamado uma vez para cada linha de dados. Vamos ver os testes parametrizados em ação.

Criar uma aula

Crie uma classe java a ser testada, digamos, PrimeNumberChecker.java em C: \> JUNIT_WORKSPACE.

public class PrimeNumberChecker {
   public Boolean validate(final Integer primeNumber) {
      for (int i = 2; i < (primeNumber / 2); i++) {
         if (primeNumber % i == 0) {
            return false;
         }
      }
      return true;
   }
}

Criar classe de caso de teste parametrizado

Crie uma classe de teste java, digamos, PrimeNumberCheckerTest.java. Crie um arquivo de classe java chamadoPrimeNumberCheckerTest.java em C: \> JUNIT_WORKSPACE.

import java.util.Arrays;
import java.util.Collection;
 
import org.junit.Test;
import org.junit.Before;

import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import org.junit.runner.RunWith;
import static org.junit.Assert.assertEquals;

@RunWith(Parameterized.class)
public class PrimeNumberCheckerTest {
   private Integer inputNumber;
   private Boolean expectedResult;
   private PrimeNumberChecker primeNumberChecker;

   @Before
   public void initialize() {
      primeNumberChecker = new PrimeNumberChecker();
   }

   // Each parameter should be placed as an argument here
   // Every time runner triggers, it will pass the arguments
   // from parameters we defined in primeNumbers() method
	
   public PrimeNumberCheckerTest(Integer inputNumber, Boolean expectedResult) {
      this.inputNumber = inputNumber;
      this.expectedResult = expectedResult;
   }

   @Parameterized.Parameters
   public static Collection primeNumbers() {
      return Arrays.asList(new Object[][] {
         { 2, true },
         { 6, false },
         { 19, true },
         { 22, false },
         { 23, true }
      });
   }

   // This test will run 4 times since we have 5 parameters defined
   @Test
   public void testPrimeNumberChecker() {
      System.out.println("Parameterized Number is : " + inputNumber);
      assertEquals(expectedResult, 
      primeNumberChecker.validate(inputNumber));
   }
}

Criar classe de executor de teste

Crie um arquivo de classe java chamado TestRunner.java em C: \> JUNIT_WORKSPACE para executar caso (s) de teste.

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(PrimeNumberCheckerTest.class);

      for (Failure failure : result.getFailures()) {
         System.out.println(failure.toString());
      }
		
      System.out.println(result.wasSuccessful());
   }
}

Compile as classes PrimeNumberChecker, PrimeNumberCheckerTest e Test Runner usando javac.

C:\JUNIT_WORKSPACE>javac PrimeNumberChecker.java PrimeNumberCheckerTest.java
TestRunner.java

Agora execute o Test Runner, que executará os casos de teste definidos na classe Test Case fornecida.

C:\JUNIT_WORKSPACE>java TestRunner

Verifique a saída.

Parameterized Number is : 2
Parameterized Number is : 6
Parameterized Number is : 19
Parameterized Number is : 22
Parameterized Number is : 23
true

Teremos um exemplo para demonstrar como executar JUnit usando ANT. Siga as etapas fornecidas abaixo.

Etapa 1: Baixe o Apache Ant

Baixe o Apache Ant com base no sistema operacional em que está trabalhando.

SO	Nome do Arquivo
janelas	apache-ant-1.8.4-bin.zip
Linux	apache-ant-1.8.4-bin.tar.gz
Mac	apache-ant-1.8.4-bin.tar.gz

Etapa 2: definir o ambiente do Ant

Colocou o ANT_HOMEvariável de ambiente para apontar para o local do diretório base, onde as bibliotecas ANT são armazenadas em sua máquina. Suponhamos que as bibliotecas Ant estejam armazenadas na pasta apache-ant-1.8.4.

Sr. Não.	SO e descrição
1	Windows Defina a variável de ambiente ANT_HOME para C: \ Arquivos de programas \ Apache Software Foundation \ apache-ant-1.8.4
2	Linux export ANT_HOME = /usr/local/apache-ant-1.8.4
3	Mac export ANT_HOME = /Library/apache-ant-1.8.4

Anexe a localização do compilador Ant ao caminho do sistema da seguinte maneira -

SO	Resultado
janelas	Anexar a string %ANT_HOME\bin no final da variável do sistema, Path.
Linux	exportar PATH = $PATH:$ANT_HOME / bin /
Mac	não requerido

Etapa 3: Baixe o arquivo JUnit

Baixe um arquivo JUnit adequado ao seu sistema operacional.

SO	Nome do Arquivo
janelas	junit4.10.jar
Linux	junit4.10.jar
Mac	junit4.10.jar

Etapa 4: Criar Estrutura do Projeto

Crie uma pasta TestJunitWithAnt em C: \> JUNIT_WORKSPACE.
Crie uma pasta src em C: \> JUNIT_WORKSPACE> TestJunitWithAnt.
Crie uma pasta test em C: \> JUNIT_WORKSPACE> TestJunitWithAnt.
Crie uma pasta lib em C: \> JUNIT_WORKSPACE> TestJunitWithAnt.
Crio MessageUtil classe em C: \> JUNIT_WORKSPACE> TestJunitWithAnt> srcfolder.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message; 
   }

   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   

   // add "Hi!" to the message
   public String salutationMessage(){
      message = "Hi!" + message;
      System.out.println(message);
      return message;
   }   
}

Crio TestMessageUtil classe na pasta C: \> JUNIT_WORKSPACE> TestJunitWithAnt> src.

import org.junit.Test;
import org.junit.Ignore;
import static org.junit.Assert.assertEquals;

public class TestMessageUtil {

   String message = "Robert";	
   MessageUtil messageUtil = new MessageUtil(message);
   
   @Test
   public void testPrintMessage() {	
      System.out.println("Inside testPrintMessage()");     
      assertEquals(message,messageUtil.printMessage());
   }

   @Test
   public void testSalutationMessage() {
      System.out.println("Inside testSalutationMessage()");
      message = "Hi!" + "Robert";
      assertEquals(message,messageUtil.salutationMessage());
   }
}

Copie junit-4.10.jar para a pasta C: \> JUNIT_WORKSPACE> TestJunitWithAnt> lib.

Criar ANT Build.xml

Estaremos usando <junit> tarefa no Ant para executar nossos casos de teste JUnit.

<project name = "JunitTest" default = "test" basedir = ".">
   <property name = "testdir" location = "test" />
   <property name = "srcdir" location = "src" />
   <property name = "full-compile" value = "true" />
	
   <path id = "classpath.base"/>
	
   <path id = "classpath.test">
      <pathelement location = "lib/junit-4.10.jar" />
      <pathelement location = "${testdir}" /> <pathelement location = "${srcdir}" />
      <path refid = "classpath.base" />
   </path>
	
   <target name = "clean" >
      <delete verbose = "${full-compile}"> <fileset dir = "${testdir}" includes = "**/*.class" />
      </delete>
   </target>
	
   <target name = "compile" depends = "clean">
      <javac srcdir = "${srcdir}" destdir = "${testdir}" 
         verbose = "${full-compile}">
         <classpath refid = "classpath.test"/>
      </javac>
   </target>
	
   <target name = "test" depends = "compile">
      <junit>
         <classpath refid = "classpath.test" />
         <formatter type = "brief" usefile = "false" />
         <test name = "TestMessageUtil" />
      </junit>
   </target>
	
</project>

Execute o seguinte comando Ant.

C:\JUNIT_WORKSPACE\TestJunitWithAnt>ant

Verifique a saída.

Buildfile: C:\JUNIT_WORKSPACE\TestJunitWithAnt\build.xml

clean:  

compile:  
   [javac] Compiling 2 source files to C:\JUNIT_WORKSPACE\TestJunitWithAnt\test
   [javac] [parsing started C:\JUNIT_WORKSPACE\TestJunitWithAnt\src\
      MessageUtil.java]
   [javac] [parsing completed 18ms]
   [javac] [parsing started C:\JUNIT_WORKSPACE\TestJunitWithAnt\src\
      TestMessageUtil.java]
   [javac] [parsing completed 2ms]
   [javac] [search path for source files: C:\JUNIT_WORKSPACE\
      TestJunitWithAnt\src]    
   [javac] [loading java\lang\Object.class(java\lang:Object.class)]
   [javac] [loading java\lang\String.class(java\lang:String.class)]
   [javac] [loading org\junit\Test.class(org\junit:Test.class)]
   [javac] [loading org\junit\Ignore.class(org\junit:Ignore.class)]
   [javac] [loading org\junit\Assert.class(org\junit:Assert.class)]
   [javac] [loading java\lang\annotation\Retention.class
      (java\lang\annotation:Retention.class)]
   [javac] [loading java\lang\annotation\RetentionPolicy.class
      (java\lang\annotation:RetentionPolicy.class)]
   [javac] [loading java\lang\annotation\Target.class
      (java\lang\annotation:Target.class)]
   [javac] [loading java\lang\annotation\ElementType.class
      (java\lang\annotation:ElementType.class)]
   [javac] [loading java\lang\annotation\Annotation.class
      (java\lang\annotation:Annotation.class)]
   [javac] [checking MessageUtil]
   [javac] [loading java\lang\System.class(java\lang:System.class)]
   [javac] [loading java\io\PrintStream.class(java\io:PrintStream.class)]
   [javac] [loading java\io\FilterOutputStream.class
      (java\io:FilterOutputStream.class)]
   [javac] [loading java\io\OutputStream.class(java\io:OutputStream.class)]
   [javac] [loading java\lang\StringBuilder.class
      (java\lang:StringBuilder.class)]
   [javac] [loading java\lang\AbstractStringBuilder.class
      (java\lang:AbstractStringBuilder.class)]
   [javac] [loading java\lang\CharSequence.class(java\lang:CharSequence.class)]
   [javac] [loading java\io\Serializable.class(java\io:Serializable.class)]
   [javac] [loading java\lang\Comparable.class(java\lang:Comparable.class)]
   [javac] [loading java\lang\StringBuffer.class(java\lang:StringBuffer.class)]
   [javac] [wrote C:\JUNIT_WORKSPACE\TestJunitWithAnt\test\MessageUtil.class]
   [javac] [checking TestMessageUtil]
   [javac] [wrote C:\JUNIT_WORKSPACE\TestJunitWithAnt\test\TestMessageUtil.class]
   [javac] [total 281ms]

test:
    [junit] Testsuite: TestMessageUtil
    [junit] Tests run: 2, Failures: 0, Errors: 0, Time elapsed: 0.008 sec
    [junit]
    [junit] ------------- Standard Output ---------------
    [junit] Inside testPrintMessage()
    [junit] Robert
    [junit] Inside testSalutationMessage()
    [junit] Hi!Robert
    [junit] ------------- ---------------- ---------------

BUILD SUCCESSFUL
Total time: 0 seconds

Para configurar o JUnit com o eclipse, siga as etapas fornecidas abaixo.

Etapa 1: Baixe o arquivo JUnit

Baixe um jar JUnit com base no sistema operacional que você tem em seu sistema.

SO	Nome do Arquivo
janelas	junit4.10.jar
Linux	junit4.10.jar
Mac	junit4.10.jar

Suponha que você tenha copiado o arquivo JAR acima para a pasta C: \> JUnit.

Etapa 2: definir o ambiente Eclipse

Abra eclipse → clique com o botão direito no projeto e clique em propriedade> Build Path> Configure Build Path e adicione junit-4.10.jar nas bibliotecas usando o botão Add External Jar.

Presumimos que seu Eclipse tenha um plugin JUnit embutido. Se não estiver disponível no diretório C: \> eclipse \ plugins, você pode baixá-lo emJUnit Plugin. Descompacte o arquivo zip baixado na pasta de plug-ins do Eclipse. Finalmente reinicie o Eclipse.

Agora seu Eclipse está pronto para o desenvolvimento de casos de teste JUnit.

Etapa 3: verificar a instalação do JUnit no Eclipse

Crie um projeto TestJunitno Eclipse em qualquer local. Em seguida, crie uma classeMessageUtil para testar no projeto.

/*
* This class prints the given message on console.
*/

public class MessageUtil {

   private String message;

   //Constructor
   //@param message to be printed
   public MessageUtil(String message){
      this.message = message;
   }
      
   // prints the message
   public String printMessage(){
      System.out.println(message);
      return message;
   }   
}

Crie uma classe de teste TestJunit no projeto.

import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class TestJunit {
	
   String message = "Hello World";	
   MessageUtil messageUtil = new MessageUtil(message);

   @Test
   public void testPrintMessage() {	  
      assertEquals(message,messageUtil.printMessage());
   }
}

A seguir deve estar a estrutura do projeto -

Finalmente, clique com o botão direito no programa e execute como JUnit para verificar a saída do programa.

Verifique o resultado.

A seguir estão as extensões JUnit -

Cactus
JWebUnit
XMLUnit
MockObject

Cacto

Cactus é uma estrutura de teste simples para teste de unidade de código java do lado do servidor (Servlets, EJBs, Tag Libs, Filtros). A intenção do Cactus é reduzir o custo de escrever testes para código do lado do servidor. Ele usa JUnit e o estende. Cactus implementa uma estratégia dentro do contêiner que executa os testes dentro de um contêiner.

O ecossistema de cactos é feito de vários componentes -

Cactus Frameworké o coração do Cactus. É o mecanismo que fornece a API para escrever testes Cactus.
Cactus Integration Modules são front-ends e frameworks que fornecem maneiras fáceis de usar o Cactus Framework (scripts Ant, plug-in Eclipse e plug-in Maven).

O código a seguir demonstra como o Cactus pode ser usado.

import org.apache.cactus.*;
import junit.framework.*;

public class TestSampleServlet extends ServletTestCase {
   @Test
   public void testServlet() {
      // Initialize class to test
      SampleServlet servlet = new SampleServlet();

      // Set a variable in session as the doSomething()
      // method that we are testing 
      session.setAttribute("name", "value");

      // Call the method to test, passing an 
      // HttpServletRequest object (for example)
      String result = servlet.doSomething(request);

      // Perform verification that test was successful
      assertEquals("something", result);
      assertEquals("otherValue", session.getAttribute("otherName"));
   }
}

JWebUnit

JWebUnit é uma estrutura de teste baseada em Java para aplicativos da web. Ele envolve as estruturas de teste existentes, como HtmlUnit e Selenium, com uma interface de teste simples e unificada para testar a exatidão de seus aplicativos da web.

JWebUnit fornece uma API Java de alto nível para navegar em um aplicativo da web combinada com um conjunto de asserções para verificar a exatidão do aplicativo. Isso inclui navegação por meio de links, entrada e envio de formulário, validação de conteúdo de tabela e outros recursos típicos de aplicativos da Web de negócios.

Os métodos de navegação simples e asserções prontas para uso permitem a criação de testes mais rápida do que usar apenas JUnit ou HtmlUnit. E se você quiser mudar de HtmlUnit para outros plug-ins como Selenium (disponível em breve), não há necessidade de reescrever seus testes.

Aqui está um código de amostra.

import junit.framework.TestCase;
import net.sourceforge.jwebunit.WebTester;

public class ExampleWebTestCase extends TestCase {
   private WebTester tester;
   
   public ExampleWebTestCase(String name) {
      super(name);
      tester = new WebTester();
   }
	
   //set base url
   public void setUp() throws Exception {
      getTestContext().setBaseUrl("http://myserver:8080/myapp");
   }
	
   // test base info
   @Test
   public void testInfoPage() {
      beginAt("/info.html");
   }
}

XMLUnit

XMLUnit fornece uma única classe de extensão JUnit, XMLTestCase, e um conjunto de classes de suporte que permitem que asserções sejam feitas sobre -

As diferenças entre duas partes do XML (por meio das classes Diff e DetailedDiff).
A validade de uma parte do XML (via classe Validator).
O resultado da transformação de um pedaço de XML usando XSLT (via classe Transform).
A avaliação de uma expressão XPath em um pedaço de XML (por meio de classes que implementam a interface XpathEngine).
Nós individuais em um fragmento de XML que são expostos pelo DOM Traversal (via classe NodeTest).

Vamos supor que temos duas peças de XML que desejamos comparar e afirmar que são iguais. Poderíamos escrever uma classe de teste simples como esta -

import org.custommonkey.xmlunit.XMLTestCase;

public class MyXMLTestCase extends XMLTestCase {

   // this test method compare two pieces of the XML
   @Test
   public void testForXMLEquality() throws Exception {
      String myControlXML = "<msg><uuid>0x00435A8C</uuid></msg>";
      String myTestXML = "<msg><localId>2376</localId></msg>";
      assertXMLEqual("Comparing test xml to control xml", myControlXML, myTestXML);
   }
}

MockObject

Em um teste de unidade, os objetos fictícios podem simular o comportamento de objetos reais complexos (não fictícios) e, portanto, são úteis quando um objeto real é impraticável ou impossível de ser incorporado em um teste de unidade.

O estilo de codificação comum para teste com objetos fictícios é -

Crie instâncias de objetos fictícios.
Defina o estado e as expectativas nos objetos fictícios.
Chame o código de domínio com objetos fictícios como parâmetros.
Verifique a consistência nos objetos fictícios.

A seguir está um exemplo de MockObject usando Jmock.

import org.jmock.Mockery;
import org.jmock.Expectations;

class PubTest extends TestCase {
   Mockery context = new Mockery();
   public void testSubReceivesMessage() {
      // set up
      final Sub sub = context.mock(Sub.class);

      Pub pub = new Pub();
      pub.add(sub);
    
      final String message = "message";
      
      // expectations
      context.checking(new Expectations() {
         oneOf (sub).receive(message);
      });

      // execute
      pub.publish(message);
      
      // verify
      context.assertIsSatisfied();
   }
}