Junit

O que é?

JUnit é um Framework de teste unitário para a linguagem programação Java.

Instalação:

Jars:

Para fazer uso do Framework é necessário fazer o download, dos Jars, que atualmente, se encontram na versão 4, através do site http://www.junit.org/

Após o download, extraia ou abra o arquivo compactado, na raiz terá o arquivo "junit-4.*.jar".

Copie ou mova esse arquivo para biblioteca e adicione o mesmo ao classpath.

Maven:

Para instalações via Maven, adicione o seguinte ao pom.xml

  <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.8.1</version>
    <scope>test</scope>
  </dependency>

Anotações: 


@Test
Anotação que marca e identifica um metodo como um metodo de Teste.
Ex.:

    @Test
    public void testSucesso() {
        // Codigo de teste
    }

@Test (expected = Exception.class)
Anotação que marca e identifica um método como um método de Teste, que espera uma exceção do tipo informado no paramento expected .
Ex.:

    @Test (expected = Exception.class)
    public void testComFalha() {
        // Codigo de teste
    }

@Test(timeout=100)
Anotação que marca e identifica um metodo como um metodo de Teste. Porem com um limite de Timeout Caso o tempo de execução do teste passar do tempo limite, o mesmo ira falhar
Ex.:

    @Test(timeout=100)
    public void testComTimeOut() {
        // Codigo de teste
    }

@Before
Anotação que marca um metodo que vai ser executado antes de cada testes Ex.:

    @Before
    public void setDados() throws Exception {
        // Codigo executado antes de cada teste  
    }

@After
Anotação que marca um metodo que vai ser executado antes de cada testes Ex.:

    @After
    public void apagarDados() throws Exception {
        // Codigo executado apos cada teste  
    }

@Ignore
Anotação que marca um método de teste, que não será executado Ex.:

    @Ignore
    public void testeIgnorado() throws Exception {
        // Este metodo de teste será ignorado
    }

@BeforeClass
Anotação que marca um método de teste para ser executado somente uma vez e antes de todos os testes. Ex.:

    @BeforeClass 
    public void cargaDadosBase() throws Exception {
        // Codigo executado somente uma vez antes de todos os testes 
    }

@AfterClass
Anotação que marca um método de teste para ser executado somente uma vez e apos todos os testes.
 Ex.:

    @AfterClass
    public void deletaCargaDados() throws Exception {
        // Codigo executado somente uma vez apos todos os testes 
    }

Asserts: 

São métodos que fazem validações perante um método de teste:


Static Import
Pode ser realizado a importação estática, conforme mostrado abaixo.
 Ex.:

import static org.junit.Assert.fail;

Assim, não é necessário usar o objeto Assert, para fazer acesso ao método. Sem a importação estática:

Assert.fail();

Com importação estática

fail();

fail() ou fail(mensagem)
Metodo força a falha do teste. Pode-se passar uma mensagem como parametro para este metodo, seria a mensagem referente a falha.
Ex:

fail();
//Ou com a mensagem
fail("Este metodo falhou.");

assertTrue(condição)
Para o metodo assertTrue é esperada uma condição de valor True, caso seja False, o teste irá falhar.
Ex.:
Teste de Sucesso:

List<String> lista = new ArrayList<String>();

Assert.assertTrue(lista.isEmpty());

Teste de Falha:

List<String> lista = new ArrayList<String>();


lista.add("Teste");
Assert.assertTrue(lista.isEmpty());

assertTrue(menssagem,condição)
Pode se fazer o mesmo uso mostrado acima e tambem passando uma menssagem que será mostrada em caso de falha.

assertFalse(condição)
Para o metodo assertFalse é esperada uma condição de valor False, caso seja True, o teste irá falhar.
Ex.:
Teste Sucesso:

List<String> lista = new ArrayList<String>();

lista.add("Teste");

Assert.assertFalse(lista.isEmpty());

Teste Falha:

List<String> lista = new ArrayList<String>();


Assert.assertFalse(lista.isEmpty());

assertFalse(menssagem,condição)
Pode se fazer o mesmo uso mostrado acima e tambem passando uma menssagem que será mostrada em caso de falha.

assertsEquals([String message], expected, actual)
Verifica se os valores dos parâmetros são os mesmos e para isso é utilizado o metodo equals() do Objeto fornecido: No caso de coleções e objetos é realizado uma comparação dos valores:
Ex.:

List<String> a = new ArrayList<String>();
List<String> b = new ArrayList<String>();

a.add("a");
b.add("a");   

Assert.assertEquals("Não são iguais", a, b);//Menssagem será exibida em caso de falha.
//Será um teste de sucesso pois as listas possuem os mesmos elementos

Para Array's:

String[] c = new String[1];
String[] d = new String[1];
    
c[0] = "a";
d[0] = "a";
    
Assert.assertEquals(c, d);
//Será uma falha, pois nesse caso é comparado os valores de referencia de memoria

assertNull([message], object)
Espera um objeto nulo, caso o objeto não seja, o teste irá falhar
Ex.

String texto = null;

Assert.assertNull(texto);

assertNotNull([message], object)
Espera um objeto não nulo, caso o objeto seja nulo, o teste irá falhar
 Ex.

String texto = "Teste";

Assert.assertNull(texto);

assertSame([String], expected, actual)
Verifica se as variáveis apontam para o mesmo objeto.
Ex.:

int a = 5;
int b = a;

Assert.assertSame("São Objetos diferentes", a, b);
//Sucesso, pois as duas variaveis apontam para o mesmo objeto.

assertNotSame([String], expected, actual)
Verifica se as variáveis apontam para objetos diferentes.
 Ex.:

int a = 5;
int b = a;

Assert.assertNotSame("São Objetos iguais", a, b);
//Sucesso, pois as duas variaveis apontam para o mesmo objeto.