aula07

Prévia do material em texto

7ºAula
Objetivos de aprendizagem
Ao término desta aula, vocês serão capazes de: 
conhecer o JUnit;
saber como criar um arquivo de testes;
entender como executar um arquivo de testes.
Olá, pessoal, tudo bem? 
Bem-vindos(as) novamente a nossa disciplina “Verificação e Validação 
de Software”. Nesta aula e na próxima, vamos fazer um projeto dirigido 
com o intuito de mostrar para vocês como funcionam as ferramentas 
de testes unitários e como funciona na prática o ciclo TDD. Nesta aula, 
vamos aprender também como criar e executar um arquivo de classe de 
testes usando a IDE Netbeans.
Leia atentamente esta aula e se tiver alguma dúvida use a sua área do 
aluno.
Bons estudos.
Bons estudos!
183
Veri cação e Validação de Soft are 40
Seções de estudo
1 - Aplicando TDD na prática
1 - Aplicando TDD na prática
Nesta aula, vamos aprender como escrever testes 
unitários de verdade, usando a metodologia TDD, abordada 
na aula 05. Nossos testes e programas se aplicarão para uma 
classe chamada Aluno, que terá as seguintes necessidades:
A classe Al no
A nossa classe de e emplo representará um aluno em uma faculdade. 
Por questões didáticas, vamos resumir o campo de responsabilidades 
dessa classe, gerenciar as notas do aluno e determinar o seu status.
Nesta faculdade o sistema de notas funciona da seguinte forma:
• No semestre regular há duas notas: P1 e P2.
• As duas notas são somadas e divididas por dois para formar a 
primeira média.
• Se a média for maior igual a 7.0, o aluno será considerado aprovado.
• Se a média for menor que 7.0, o aluno terá a necessidade de fazer 
uma prova substitutiva.
• Quando o aluno faz uma prova substitutiva, a sua respectiva nota 
elimina a pior nota entre a P1 e a P2.
• Um novo cálculo da média aritmética é feito entre o resultado da 
prova substitutiva e a maior nota entre a P1 e a P2.
• Se a média for maior igual a sete, o aluno estará aprovado.
• Se a média for menor que três, o aluno estará reprovado.
• Se a média for maior igual a três e menor que sete, o aluno deverá 
fazer o e ame. Uma nova média aritmética é calculada entre a média 
da P1 e P2 com a nota do e ame.
• Se essa nova média for maior igual a cinco, o aluno será considerado 
aprovado.
• Se a média for menor que cinco, o aluno será considerado reprovado.
Assim, foram levantados os seguintes atributos para essa classe:
• notaP1, que armazena a nota da P1;
• notaP2, que armazena a nota da P2;
• notaSub, que armazena a nota da prova substitutiva e;
• notaE ame, que armazena a nota do e ame.
Além disso, foram levantados quatro métodos para essa classe:
• calcularMedia, que calcula a média entre a P1 e a P2;
• calcularMediaSub, que calcula a média entre a maior nota entre a P1 
e P2 e a nota da substitutiva;
• calcularMediaE ame, que calcula a média entre a média anterior com 
a nota do e ame;
• status, que retorna o status do aluno de acordo com a situação do 
aluno. Essa situação pode ser:
→ “Cursando”, se nenhuma nota for informada.
→ “Necessário fazer Sub”.
→ “Necessário fazer E ame”.
→ “Reprovado”.
→ “Aprovado”.
Assim, foi desenvolvido a seguinte lista de funcionalidades a ser 
implementadas para esse processo de criação da classe aluno:
1. Implementar o método status, para que retorne o status cursando.
2. Implementar o método calcularMédia.
3. Implementar a veri cação se o aluno está em sub ou não no 
método status (as regras serão da Unigran).
4. Implementar o método calcularMédiaSub.
5. Implementar a veri cação se o aluno está em e ame ou não.
6. Implementar o método calculaMédiaE ame.
7. Implementar a veri cação se o aluno está em DP ou não.
Durante o processo de criação, usaremos esta lista para ordenar e 
guiar a nossa tarefa.
Para esta aula, programaremos a nossa classe Aluno e os 
nossos testes usando a linguagem Java, usando o framework 
JUnit (https://junit.org/junit5/) para escrever os nossos 
testes unitários. Para a nossa programação, usaremos a IDE 
Netbeans, que vem com o JUnit integrado.
nstalação do D e do et eans
Para mais detalhes sobre a instalação do Netbeans e do JDK - 
necessários para o desenvolvimento do nosso projeto -, siga o nosso 
tutorial desenvolvido que está disponível na seção: “Arquivos”, da sua 
Área do Aluno.
Caso já tenha instalado, ignore essa parte.
Com o Netbeans instalado, abra-o. Você verá a seguinte 
tela:
Depois, vá ao menu “File” (Arquivo) e depois clique em 
“New Project” (Novo Projeto).
184
41
Na janela que vai aparecer, clique na opção “Java” na 
área “Categories” (Categorias) e na opção “Java Application” 
(Aplicação Java) na área “Projects” (Projetos). Em seguida, 
clique em “Next” (Próximo).
Depois, no campo “Project Name” (Nome do Projeto), 
dê um nome ao projeto. No nosso exemplo, vamos dar o 
nome “AlunoTDD”. Em seguida, clique no botão “Finish” 
(Terminar).
Um novo projeto é criado e será aberto no Netbeans.
Com o projeto criado, vamos criar um pacote para a nossa 
classe Aluno. Posicione o mouse sobre o pacote “alunotdd”, 
criado automaticamente pelo Netbeans. Depois, clique no 
botão direito do mouse. No menu pop-up que surgir clique 
em “New >” (Novo) e depois em “Java Package” (Pacote 
Java).
Na janela que aparecer dê um nome ao pacote no campo 
“Package Name” (Nome do Pacote). No nosso exemplo, 
vamos dar o nome “classes”. Depois, clique no botão “Finish” 
(Terminar) para efetivar o salvamento do pacote.
Depois disso, o pacote classes já estará listado na árvore 
do projeto.
Agora, vamos criar a nossa classe Aluno. Para isso, pouse 
o mouse em cima do pacote classes, clique no botão direito do 
mouse, clique no botão “New >” (Novo) e depois em “Java 
Class” (Classe Java).
185
Veri cação e Validação de Soft are 42
No campo “Class Name” da janela que surgir, dê o 
nome “Aluno”. Depois, clique em “Finish” (Terminar) para 
salvar a classe. A classe estará listada na árvore do projeto, e 
o Netbeans já abrirá o arquivo da classe com o seu esqueleto 
básico já criado.
Agora, vamos criar o nosso teste. Para isso, clique com 
o botão direito em qualquer arquivo ou pacote do painel 
esquerdo do projeto no Netbeans. No menu que surgir clique 
em “New >” (Novo) e depois em “Other” (Outro).
Na janela que surgir clique em “Unit Tests” (Testes de 
Unidades) no painel “Categories” (Categorias). Em seguida, 
no painel “File Types” (Tipos de Arquivo) clique em JUnit 
Test (Teste JUnit). Feito isso, clique em “Next >” (Próximo).
Depois, no campo “Class Name” (Nome da Classe) 
especifique qual será o nome da classe de testes. No nosso 
exemplo, ele vai ter o nome “AlunoTest”. No campo 
“Package” (Pacote), especificamos qual pacote a classe vai 
pertencer. Indicamos o nome classes, para ficar com o mesmo 
nome do pacote a qual a classe Aluno pertence. Feito isso, 
clique em “Finish” (Terminar):
A nova classe aparecerá na árvore de projetos, na pasta 
“Test packages” (Pacotes de Testes). Além disso, o Netbeans 
abrirá automaticamente o arquivo.
186
43
O arquivo AlunoTest.java ficará mais ou menos assim: 
*
 * To change this license header, choose License Headers in Project 
Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 *
package classes;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
**
 *
 * @author DI
 *
public class AlunoTest 
 
 public AlunoTest() 
 }
 
 @BeforeClass
 public static void setUpClass() 
 }
 
 @AfterClass
 public static void tearDo nClass() 
 }
 
 @Before
 public void setUp() 
 }
 
 @After
 public void tearDo n() 
 }
 TODO add test methods here.
 The methods must be annotated ith annotation @Test. For 
e ample:
 
 @Test
 public void hello() }
}
Não se preocupem com tudo isso. Vamos explicar o que 
esses métodos adicionais fazem mais adiante. Com o teste 
criado, adicione antes do construtor o atributo Aluno:
public Aluno aluno;
Em seguida, vamoscriar o nosso primeiro teste. Como já 
foi esclarecido no início da nossa aula, vamos seguir a ordem 
que definimos em nosso projeto. Assim, primeiro, vamos 
implementar o teste para o método status da classe Aluno. 
Esse método tem como objetivo mostrar qual é o status do 
aluno naquele instante. Como o aluno ainda não tem notas, 
vamos definir que a função status retorne sempre o texto 
“Cursando”.
Mas, como prega o TDD, vamos para o teste antes. 
Assim, apague as linhas:
 TODO add test methods here.
 The methods must be annotated ith annotation @Test. For 
e ample:
 
 @Test
 public void hello() }
E depois insira o seguinte método de teste:
 @Test
 public void testStatusCursando()
 aluno = ne Aluno();
 
 assertEquals(“Cursando”, aluno.status());
 }
Como já foi dito na aula 06, todo teste no JUnit é um método que é 
precedido pela anotação @Test, que indica, e plicitamente, para o 
JUnit que se trata de um teste.
Agora, vamos rodar os nossos testes. Para isso, posicione 
o mouse em cima do arquivo AlunoTest.java e clique com 
o botão direito do mouse nele. No menu que surgir clique 
no botão “Test File” (Testar Arquivo). Outra forma é usar o 
atalho de teclado Control + F6.
187
Veri cação e Validação de Soft are 44
O Netbeans vai detectar um erro e vai perguntar se você 
quer realmente executar esse teste. Clique em “Run Anyway” 
(Executar Mesmo Assim).
Na parte inferior da janela do Netbeans vai aparecer um 
painel chamado “Test Results” (Resultados do Teste), que vai 
informar o resultado dos testes. Neste painel há uma barrinha 
que muda de cor. Se essa barra ficar vermelha, quer dizer 
que um ou mais testes falharam. Se a barrinha ficar verde, 
quer dizer que todos os testes passaram. Abaixo dessa barra 
será exibido mais detalhes a respeito da execução. No nosso 
exemplo, a barra ficou vermelha, pois os testes falharam.
Bem, isso foi esperado, pois não temos implementação 
alguma do método status. Isso, vamos fazer agora. Abra o 
arquivo Aluno.java e insira o seguinte método:
public String status()
 return “Cursando”;
}
Você deve estar se perguntando: só isso? Isso mesmo. 
O TDD prega pela simplicidade. Como nós estamos 
fazendo um teste que só espera que o programa retorne a 
palavra “Cursando”, fazemos isso. A medida que as novas 
funcionalidades são implementadas, colocamos. Mas somente 
quando há a necessidade.
Salve o arquivo e rode o teste novamente. Agora sim, o 
teste passa e a barra fica verde.
Passado essas duas etapas, chegamos a fase da refatoração. 
Mas não precisamos nesse momento. Assim, avançamos para 
a nossa segunda funcionalidade: O cálculo da média da P1 e 
P2. Adicione o seguinte método:
 @Test
 public void testCalcularMedia()
 aluno = ne Aluno();
 
 aluno.notaP1 = 6;
 aluno.notaP2 = 8;
 
 assertEquals(7, aluno.calcularMedia());
 }
Na sequência, execute o teste. O teste vai falhar, pois não 
temos implementação alguma. Assim, vá ao arquivo Aluno.
java. Primeiramente, vamos adicionar os dois atributos que 
representam as notas do aluno. Coloque antes da definição do 
método status:
public float notaP1;
public float notaP2;
Em seguida, implementamos a função calcularMedia:
public float calcularMedia()
 return (notaP1 + notaP2) 2;
}
Feito isso, salve o arquivo e rode o teste. O teste vai 
passar? Infelizmente não:
Expandi a área de resultados para ver a informação. 
O erro foi causado pelo fato que estamos comparando 
um número de ponto flutuante, que nem sempre estará no 
seu valor exato. Um número 5.5 pode ser armazenado no 
computador como 5.50001, por exemplo. Isso é da natureza 
de armazenamento dos dados. 
Para lidar com isso, o método assertEquals possui um 
terceiro parâmetro, denominado de delta. Esse delta é uma 
faixa de variação em que o número de ponto flutuante pode 
variar. Por exemplo, se queremos que uma variável de ponto 
flutuante tenha um valor 6 e declararmos um delta de 0.001, 
significa que o valor pode transitar entre 5.999 a 6.001. Graças 
188
45
a esse parâmetro temos uma garantia que o número de ponto 
flutuante seja testado.
Portanto, altere a linha:
assertEquals(7, aluno.calcularMedia());
Por:
assertEquals(7, aluno.calcularMedia(), 0.001);
Rode o teste. Agora ele passa.
Com os testes passando, vamos para a fase da 
refatoração. Mas ainda não vemos a necessidade de melhorar 
o código. Vamos para a nossa próxima funcionalidade, que 
é a atualização da nossa função de status. Vamos testar três 
situações:
 Se a média for maior igual a sete, ele deve retornar 
“Aprovado”.
 Se a média for menor que sete, ele deve retornar 
“Necessário fazer Sub”.
Assim, temos que escrever dois testes, sendo um para 
cada caso. Vamos ao código deles.
 @Test
 public void testStatusAprovadoDireto()
 aluno = ne Aluno();
 
 aluno.notaP1 = 7;
 aluno.notaP2 = 8;
 
 assertEquals(“Aprovado”, aluno.status());
 }
 
 @Test
 public void testStatusSub()
 aluno = ne Aluno();
 
 aluno.notaP1 = 6;
 aluno.notaP2 = 6;
 
 assertEquals(“Necessário fazer Sub”, aluno.status());
 }
Rode os testes. Como esperado, os testes falham.
Como você pode ver na mensagem, estávamos esperando 
textos diferentes. Mas a função status, nesse instante, só 
retorna a palavra “Cursando”. Precisamos criar a lógica de 
verificação para esse método. Assim, traçamos os seguintes 
passos para o método status:
 Se as notas não forem definidas, ele retorna o texto 
“Cursando”.
 Se as notas forem definidas, ele calcula a média, 
podendo cair nas seguintes situações:
 Se a média for maior igual a sete, o método retorna o 
status “Aprovado”.
 Se a média for menor que sete, o método retorna o 
status “Necessário fazer Sub”.
Assim, vamos por a mão no código. Reflita um pouco 
antes de avançar na leitura como seria a implementação disso. 
A seguir, apresentaremos a nova implementação do método 
status:
 public float notaP1 = -1;
 public float notaP2 = -1;
 
 public String status()
 
 if (notaP1 0 && notaP2 0)
 return “Cursando”;
 }
 
 float media = calcularMedia();
 
 if (media = 7.0)
 return “Aprovado”;
 }else
 return “Necessário fazer Sub”;
 }
 }
Nesse código, estamos fazendo vários testes. 
Primeiramente, adotamos um valor padrão para as notas 
P1 e P2, para indicar que não foram atribuídas pelo usuário. 
Colocamos o valor -1 na declaração dos atributos para indicar 
isso. No método status, verificamos se as notas P1 e P2 são 
menores que zero. Se for, as notas não estão atribuídas. Assim, 
retornamos a string “Cursando” para esse caso.
Se as notas P1 e P2 forem iguais ou maiores que zero, 
significa que as notas já foram atribuídas. Assim, podemos 
fazer o cálculo da média e fazer a verificação se o aluno está 
aprovado (caso tenha média igual ou maior que 7.0) ou não.
Rode os testes. Agora eles funcionam.
E com isso, finalizamos a nossa aula. Na próxima aula, 
vamos seguir com o ciclo TDD para terminar a implementação 
da classe Aluno. Até lá!
189
Veri cação e Validação de Soft are 46
Retomando a aula
Chegamos ao nal da sétima aula. Vamos relembrar?
1 - Aplicando TDD na prática
Nessa seção, aprendemos como fazer um arquivo de 
testes na IDE Netbeans. Além disso, vocês aprenderam 
como executar os seus testes dentro dessa ferramenta, e como 
comparar valores, usando o método assertEquals.
ANICHE, Maurício. Test-Driven Development: Teste e 
Design no Mundo Real. São Paulo: Casa do Código, 2012.
SOMMERVILLE, Ian. Engenharia de software. 9. ed. São 
Paulo: Pearson Addison Wesley, 2014.
PRESSMAN, Roger S. Engenharia de software: uma 
abordagem profissional. 8. ed. São Paulo: McGraw-Hill; 
Porto Alegre: Bookman; Santana: AMGH Editora, 2016.
Vale a pena ler
Vale a pena
ANICHE, Maurício. TDD. Caelum, 2014. Disponível 
em: < http://tdd.caelum.com.br/>. Acesso em: 16 set. 2018.
GAMA, Alexandre. Test Driven Development: TDD 
Simples e Prático. DevMedia, 2010. Disponível em: < ht-
tps://www.devmedia.com.br/test-driven-development-
tdd-simples-e-pratico/1853 >. Acesso em: 16 set. 2018.
Vale a pena acessar
Minhas anotações
190