Classes abstratas são referidas como a classe declarada com a palavra-chave abstrata que pode ou não incluir os métodos abstratos. Em Java, classes abstratas não podem ser instanciadas, mas podem ser subclassificadas. Também pode ter campos estáticos e métodos estáticos.

Nesta seção, discutiremos a simulação ou espionagem de classes abstratas. Analisaremos vários casos de teste de classes abstratas usando métodos não abstratos.

Para espionar ou zombar das classes abstratas, precisamos adicionar as seguintes dependências do Maven:

• JUnit
• Mockito
• PowerMock

Todas as dependências necessárias do projeto são fornecidas abaixo:

 junit junit 4.12 test org.mockito mockito-all 1.10.19 test org.powermock powermock-module-junit4 1.7.4 test org.powermock powermock-api-mockito 1.7.0 test 

As dependências do PowerMock são necessárias apenas para o teste em que utilizamos o PowerMock.

tipos de dados primitivos em java

Exemplos de aula abstrata simulada

1. Espiando classe abstrata usando Mockito.spy()

Neste exemplo, vamos espionar as classes abstratas usando o método Mockito.spy(). O método Mockito.spy() é usado para criar uma instância espiã da classe abstrata.

Passo 1: Crie uma classe abstrata chamada Abstract1_class que contenha métodos abstratos e não abstratos.

Abstract1_class.java

somador somador completo

 public abstract class Abstract1_class { public abstract int newAbstractmethod(); public String methodUnderTest() { return 'one' ; } } 

Passo 2: Crie um caso de teste JUnit chamado Resumo1Teste . Ele contém uma instância espiã da classe abstrata.

Resumo1Test.java

 import static org.junit.Assert.*; import org.junit.Test; import org.mockito.Mockito; import junit.framework.Assert; public class Abstract1Test { @Test public void testing_usingSpy() { Abstract1_class abstclas = Mockito.spy(Abstract1_class.class); String res = abstclas.methodUnderTest(); Assert.assertEquals('one', res); } } 

Saída

A saída a seguir mostra que o teste está sendo executado com êxito.

A desvantagem de usar o método Mockito.spy() é que ele invocará o construtor da classe abstrata durante a criação da instância espiã. Na maioria dos casos, o construtor utiliza dependências externas que podem ser um obstáculo para a execução dos nossos testes unitários. Essas dependências externas são geralmente conhecidas como impedimentos de teste . É a razão para usar o método Mockito.mock() para simular classes abstratas.

2. Simulação de classe abstrata usando Mockito.mock()

Neste exemplo, vamos simular as classes abstratas usando o método Mockito.mock().

Normalmente, a zombaria é usada para criar um clone ou objeto fictício da classe. Em outras palavras, deixa uma classe vazia de sua lógica ou algoritmos. A instância simulada criada não contém código (lógica) dentro dos métodos.

Passo 1: Crie uma classe abstrata chamada Abstract_Class que contenha métodos abstratos e não abstratos.

Abstract_Class.java

o que é $ home linux

 public abstract class Abstract_Class { public String sayMock() { return 'Hii.. ' + getName() + symbol() ; } private String symbol() { return '!!'; } protected abstract String getName(); } 

Passo 2: Crie um caso de teste JUnit chamado AbstratoTestClass por zombar da classe abstrata.

ResumoTestClass.java

 import static org.junit.Assert.*; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.when; import org.junit.Test; public class AbstractTestClass { @Test public void test_AbstractClasses() { Abstract_Class ac = mock(Abstract_Class.class); when(ac.sayMock()).thenCallRealMethod(); when(ac.getName()).thenReturn('Jyotika'); assertEquals('Hii.. Jyotika!!', ac.sayMock()); } } 

No código acima, e é uma instância simulada criada usando o método Mockito.mock().

Saída

A saída a seguir mostra que o teste está sendo executado com êxito usando o Mockito.

A abordagem acima não é a melhor, mas pode ser usada. A próxima abordagem é recomendada porque usa PowerMock e pode ter controle sobre os métodos privados definidos nas classes abstratas.

3. Zombando de classe abstrata usando PowerMock

No exemplo a seguir, usaremos o método PowerMockito.mock() para simular as classes abstratas. Usar PowerMock em vez de Mockito.mock() é uma abordagem melhor, pois pode ter controle sobre métodos privados e estáticos.

Passo 1: Crie uma classe abstrata chamada Classe_abstrata que contém métodos abstratos e não abstratos.

Abstract_class.java

 public abstract class Abstract_Class { public abstract int myAbstractMethod(); public String sayMock() { return getName() + '13' ; } private String getName() { return 'Jyotika'; } } 

Passo 2: Crie um caso de teste JUnit chamado AbstratoTestClass para fins de teste.

ResumoTestClass.java

código de codificação huffman

 import static org.junit.Assert.*; import org.junit.Test; import org.junit.runner.RunWith; import org.powermock.api.mockito.PowerMockito; import org.powermock.core.classloader.annotations.PrepareForTest; import org.powermock.modules.junit4.PowerMockRunner; @RunWith(PowerMockRunner.class) @PrepareForTest( Abstract_Class.class) public class AbstractTestClass { @Test public void test_AbstractClassesusing_PowerMock() throws Exception { // given Abstract_Class ac = PowerMockito.mock(Abstract_Class.class); PowerMockito.doCallRealMethod().when(ac).sayMock(); PowerMockito.doReturn('Sharma').when(ac , 'getName'); //when String newstring = ac.sayMock(); //then assertEquals('Sharma13', newstring); System.out.println(newstring); } } 

Aqui, pedimos ao PowerMock para fazer um stub dos valores de retorno do método privado para que possamos testar o método sayMock() sem quaisquer impedimentos de teste. O Mockito sozinho não pode fazer stub desse método, é por isso que usamos o PowerMock junto com o Mockito.

Saída

A saída a seguir mostra que o teste está sendo executado com êxito usando PowerMock com Mockito.

---