Espresso Testing Framework - Visão geral do JUnit

Neste capítulo, vamos entender os fundamentos do JUnit , a estrutura de teste de unidade popular desenvolvida pela comunidade Java na qual a estrutura de teste do espresso é construída.

JUnit é o padrão de fato para teste de unidade de um aplicativo Java. Mesmo assim, é popular para teste de unidade, ele tem suporte completo e provisão para teste de instrumentação também. A biblioteca de teste do Espresso estende as classes JUnit necessárias para dar suporte ao teste de instrumentação baseado em Android.

Escreva um Teste de Unidade Simples

Vamos criar uma classe Java, Computation (Computation.java) e escrever uma operação matemática simples, Soma e Multiplicação . Em seguida, escreveremos casos de teste usando JUnit e verificaremos executando os casos de teste.

Inicie o Android Studio.
Abra HelloWorldApp criado no capítulo anterior.
Crie um arquivo, Computation.java em app / src / main / java / com / tutorialspoint / espressosamples / helloworldapp / e escreva duas funções - Soma e Multiplica conforme especificado abaixo,

package com.tutorialspoint.espressosamples.helloworldapp;
public class Computation {
   public Computation() {}
   public int Sum(int a, int b) {
      return a + b;
   }
   public int Multiply(int a, int b) {
      return a * b;
   }
}

Crie um arquivo, ComputationUnitTest.java em app / src / test / java / com / tutorialspoint / espressosamples / helloworldapp e escreva casos de teste de unidade para testar a funcionalidade Soma e Multiplicação conforme especificado abaixo

package com.tutorialspoint.espressosamples.helloworldapp;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
public class ComputationUnitTest {
   @Test
   public void sum_isCorrect() {
      Computation computation = new Computation();
      assertEquals(4, computation.Sum(2,2));
   }
   @Test
   public void multiply_isCorrect() {
      Computation computation = new Computation();
      assertEquals(4, computation.Multiply(2,2));
   }
}

Aqui, usamos dois novos termos - @Test e assertEquals . Em geral, JUnit usa anotação Java para identificar os casos de teste em uma classe e informações sobre como executar os casos de teste. @Test é uma dessas anotações Java, que especifica que a função particular é um caso de teste junit. assertEquals é uma função para afirmar que o primeiro argumento (valor esperado) e o segundo argumento (valor calculado) são iguais e iguais. JUnit fornece vários métodos de asserção para diferentes cenários de teste.

Agora, execute o ComputationUnitTest no Android Studio clicando com o botão direito na classe e invocando a opção Executar 'ComputationUnitTest' conforme explicado no capítulo anterior. Isso executará os casos de teste de unidade e relatará o sucesso.

O resultado do teste de unidade de computação é mostrado abaixo -

Anotações

A estrutura JUnit usa anotações extensivamente . Algumas das anotações importantes são as seguintes -

@Test
@Before
@After
@BeforeClass
@AfterClass
@Rule

Anotação @Test

@Test é a anotação muito importante na estrutura JUnit . @Test é usado para diferenciar um método normal do método de caso de teste. Depois que um método é decorado com a anotação @Test , esse método específico é considerado um caso de teste e será executado pelo JUnit Runner . JUnit Runner é uma classe especial, que é usada para encontrar e executar os casos de teste JUnit disponíveis dentro das classes java. Por enquanto, estamos usando a opção integrada do Android Studio para executar os testes de unidade (que por sua vez executam o JUnit Runner ). Um exemplo de código é o seguinte,

package com.tutorialspoint.espressosamples.helloworldapp;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class ComputationUnitTest {
   @Test
   public void multiply_isCorrect() {
      Computation computation = new Computation();
      assertEquals(4, computation.Multiply(2,2));
   }
}

@Antes

A anotação @Before é usada para referir-se a um método, que precisa ser chamado antes de executar qualquer método de teste disponível em uma classe de teste específica. Por exemplo, em nosso exemplo, o objeto Computation pode ser criado em um método separado e anotado com @Before para que seja executado antes dos casos de teste sum_isCorrect e multiply_isCorrect . O código completo é o seguinte,

package com.tutorialspoint.espressosamples.helloworldapp;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class ComputationUnitTest {
   Computation computation = null;
   @Before
   public void CreateComputationObject() {
      this.computation = new Computation();
   }
   @Test
   public void sum_isCorrect() {
      assertEquals(4, this.computation.Sum(2,2));
   }
   @Test
   public void multiply_isCorrect() {
      assertEquals(4, this.computation.Multiply(2,2));
   }
}

@Depois de

@After é semelhante a @Before , mas o método anotado com @After será chamado ou executado após a execução de cada caso de teste. O código de amostra é o seguinte,

package com.tutorialspoint.espressosamples.helloworldapp;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class ComputationUnitTest {
   Computation computation = null;
   @Before
   public void CreateComputationObject() {
      this.computation = new Computation();
   }
   @After
   public void DestroyComputationObject() {
      this.computation = null;
   }
   @Test
   public void sum_isCorrect() {
      assertEquals(4, this.computation.Sum(2,2));
   }
   @Test
   public void multiply_isCorrect() {
      assertEquals(4, this.computation.Multiply(2,2));
   }
}

@Antes da aula

@BeforeClass é semelhante a @Before , mas o método anotado com @BeforeClass será chamado ou executado apenas uma vez antes de executar todos os casos de teste em uma classe particular. É útil criar um objeto de uso intensivo de recursos, como um objeto de conexão de banco de dados. Isso reduzirá o tempo de execução de uma coleção de casos de teste. Este método precisa ser estático para funcionar corretamente. Em nosso exemplo, podemos criar o objeto de computação uma vez antes de executar todos os casos de teste, conforme especificado abaixo,

package com.tutorialspoint.espressosamples.helloworldapp;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class ComputationUnitTest {
   private static Computation computation = null;
   @BeforeClass
   public static void CreateComputationObject() {
      computation = new Computation();
   }
   @Test
   public void sum_isCorrect() {
      assertEquals(4, computation.Sum(2,2));
   }
   @Test
   public void multiply_isCorrect() {
      assertEquals(4, computation.Multiply(2,2));
   }
}

@Depois da aula

@AfterClass é semelhante a @BeforeClass , mas o método anotado com @AfterClass será chamado ou executado apenas uma vez depois que todos os casos de teste em uma classe particular forem executados. Este método também precisa ser estático para funcionar corretamente. O código de amostra é o seguinte -

package com.tutorialspoint.espressosamples.helloworldapp;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.assertEquals;

public class ComputationUnitTest {
   private static Computation computation = null;
   @BeforeClass
   public static void CreateComputationObject() {
      computation = new Computation();
   }
   @AfterClass
   public static void DestroyComputationObject() {
      computation = null;
   }
   @Test
   public void sum_isCorrect() {
      assertEquals(4, computation.Sum(2,2));
   }
   @Test
   public void multiply_isCorrect() {
      assertEquals(4, computation.Multiply(2,2));
   }
}

@Regra

A anotação @Rule é um dos destaques do JUnit . É usado para adicionar comportamento aos casos de teste. Podemos apenas anotar os campos do tipo TestRule . Ele realmente fornece conjunto de recursos fornecidos pelo @Before e @After anotação, mas de uma forma eficiente e reutilizável. Por exemplo, podemos precisar de uma pasta temporária para armazenar alguns dados durante um caso de teste. Normalmente, precisamos criar uma pasta temporária antes de executar o caso de teste (usando a anotação @Before ou @BeforeClass) e destruí-la após a execução do caso de teste (usando a anotação @After ou @AfterClass). Em vez disso, podemos usar a classe TemporaryFolder (do tipo TestRule ) fornecida pela estrutura JUnit para criar uma pasta temporária para todos os nossos casos de teste e a pasta temporária será excluída quando o caso de teste for executado. Precisamos criar uma nova variável do tipo TemporaryFolder e anotar com @Rule conforme especificado abaixo,

package com.tutorialspoint.espressosamples.helloworldapp;

import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import java.io.File;
import java.io.IOException;
import static junit.framework.TestCase.assertTrue;
import static org.junit.Assert.assertEquals;

public class ComputationUnitTest {
   private static Computation computation = null;
   @Rule
   public TemporaryFolder folder = new TemporaryFolder();
   @Test
   public void file_isCreated() throws IOException {
      folder.newFolder("MyTestFolder");
      File testFile = folder.newFile("MyTestFile.txt");
      assertTrue(testFile.exists());
   }
   @BeforeClass
   public static void CreateComputationObject() {
      computation = new Computation();
   }
   @AfterClass
   public static void DestroyComputationObject() {
      computation = null;
   }
   @Test
   public void sum_isCorrect() {
      assertEquals(4, computation.Sum(2,2));
   }
   @Test
   public void multiply_isCorrect() {
      assertEquals(4, computation.Multiply(2,2));
   }
}

Ordem de Execução

No JUnit , os métodos anotados com anotações diferentes serão executados em ordem específica conforme mostrado abaixo,

@BeforeClass
@Rule
@Before
@Test
@After
@AfterClass

Afirmação

Asserção é uma forma de verificar se o valor esperado do caso de teste corresponde ao valor real do resultado do caso de teste. JUnit fornece asserção para diferentes cenários; algumas afirmações importantes estão listadas abaixo -

fail() - Para fazer explicitamente um caso de teste falhar.
assertTrue(boolean test_condition) - Verifica se test_condition é verdadeiro
assertFalse(boolean test_condition) - Verifica se test_condition é falso
assertEquals(expected, actual) - Verifica se ambos os valores são iguais
assertNull(object) - Verifica se o objeto é nulo
assertNotNull(object) - Verifica se o objeto não é nulo
assertSame(expected, actual) - Verifica se ambos se referem ao mesmo objeto.
assertNotSame(expected, actual) - Verifica se ambos se referem a objetos diferentes.

↰ Previous page Next page ↱