04 Lista exercicios teste JUnit TDD

Prévia do material em texto

Lista de Exercícios: Teste de Unidade
Prof. André Takeshi Endo
JUnit e TDD
(Exercício 1) Triângulo. Especifique um conjunto de casos de teste para testar o
programa a seguir:
O programa lê três valores inteiros que representam os lados de um triângulo. O
programa informa se os lados formam um triângulo isósceles, escaleno ou equilatero.
Condição: a soma de dois lados tem que ser maior que o terceiro lado.
(i) Defina o esqueleto de uma classe Java que resolva o problema acima.
(ii) Escreva casos de teste em JUnit para as seguintes situações:
• Triângulo escaleno válido
• Triângulo isósceles válido
• Triângulo equilatero válido
• Pelo menos 3 casos de teste (CTs) para isósceles válido contendo a permutação
dos mesmos valores
• Um valor zero
• Um valor negativo
• A soma de 2 lados é igual ao terceiro lado
• Para o item acima, um CT para cada permutação de valores
• CT em que a soma de 2 lados é menor que o terceiro lado
• Para o item acima, um CT para cada permutação de valores
• Um CT para os três valores iguais a zero
(Exercício 2) Considere o conjunto de classes abaixo. Utilizando uma abordagem TDD,
implemente o método “ehValidoParaInclusao()”. Esse método deve retornar uma lista
de erros com base no objeto Pessoa passado como parâmetro. Deve ser validado:
• O nome é composto por ao menos 2 partes e deve ser composto de letras
• A idade deve estar no intervalo [1,200]
• A pessoa deve ter pelo menos um objeto da classe e-mail associado
• O e-mail deve estar no formato “___@___.___”, sendo que cada parte deve ter
ao menos um caractere
(Exercício 3) Número aleatório em um intervalo. Seguindo um ciclo Test Driven
Development (TDD), desenvolva as classes abaixo usando JUnit para automatizar os
testes.
(1) MyRandomNumber.java
public class MyRandomNumber {
 Random random = new Random(); 
 
 /**
 * 
 * @param begin inicio do intervalo
 * @param end fim do intervalo
 * @return retornar um numero aleatorio entre [begin, end]
 * o numero aleatorio retornado nao pode ser igual ao anterior
 * @throws IntervaloInvalidoException
 * essa excecao eh lancada quando begin >= end ou (begin<0 || end<0)
 * 
 */
 public int nextRandomNumber(int begin, int end) throws IntervaloInvalidoException {
 if(begin < 0)
 throw new IntervaloInvalidoException("begin eh menor que zero");
 
 //TODO implementar o codigo aqui
 return -1;
 }
}
(2) IntervaloInvalidoException.java
public class IntervaloInvalidoException extends Exception {
 public IntervaloInvalidoException(String msg) {
 super(msg);
 }
}
(Exercício 4) Seguindo um ciclo Test Driven Development (TDD), desenvolva as
classes necessárias (usando a linguagem Java e o framework JUnit) para resolver o
problema descrito abaixo:
“O participante deve implementar uma calculadora de salário de funcionários. Um
funcionário contém nome, e-mail, salário-base e cargo. De acordo com seu cargo, a
regra para cálculo do salário líquido é diferente:
• Caso o cargo seja DESENVOLVEDOR, o funcionário terá desconto de 20%
caso o salário seja maior ou igual que 3.000,00, ou apenas 10% caso o salário
seja menor que isso. 
• Caso o cargo seja DBA, o funcionário terá desconto de 25% caso o salário seja
maior ou igual que 2.000,00, ou apenas 15% caso o salário seja menor que
isso.
• Caso o cargo seja TESTADOR, o funcionário terá desconto de 25% caso o
salário seja maior ou igual que 2.000,00, ou apenas 15% caso o salário seja
menor que isso. 
• Caso o cargo seja GERENTE, o funcionário terá desconto de 30% caso o
salário seja maior ou igual que 5.000,00, ou apenas 20% caso o salário seja
menor que isso.
Exemplos de cálculo do salário:
• DESENVOLVEDOR com salário-base 5,000.00. Salário final = 4.000,00
• GERENTE com salário-base de 2.500,00. Salário final: 2.000,00
• TESTADOR com salário de 550.00. Salário final: 467,50” (Aniche, 2012).
(Exercício 5) Seguindo um ciclo Test Driven Development (TDD), desenvolva as
classes necessárias (usando a linguagem Java e o framework JUnit) para resolver o
problema descrito abaixo:
“O participante deve implementar um sistema de geração de nota fiscal a partir de
uma fatura. Uma fatura contém o nome e endereço do cliente, tipo do serviço e valor
da fatura. O gerador de nota fiscal deverá gerar uma nota fiscal que contém nome do
cliente, valor da nota e valor do imposto a ser pago.
 
O valor da nota é o mesmo do valor da fatura. Já o cálculo do imposto a ser pago deve
seguir as seguintes regras:
 
• Caso o serviço seja do tipo "CONSULTORIA", o valor do imposto é de 25%;
• Caso o serviço seja do tipo "TREINAMENTO", o valor do imposto é 15%;
• Qualquer outro, o valor do imposto é 6%.
 
Ao final da geração da nota fiscal, o sistema ainda deve enviar essa nota por e-mail,
para o SAP, e persistir na base de dados. Por simplicidade, o desenvolvedor pode usar
os códigos abaixo, que simulam o comportamento do SMTP, SAP e banco de dados:
 
class NotaFiscalDao {
public void salva(NotaFiscal nf) {
System.out.println("salvando no banco");
}
}
 
class SAP {
public void envia(NotaFiscal nf) {
System.out.println("enviando pro sap");
}
}
 
class Smtp {
public void envia(NotaFiscal nf) {
System.out.println("enviando por email");
}
}” (Aniche, 2012).
(Exercício 6) Seguindo um ciclo Test Driven Development (TDD), desenvolva as
classes necessárias (usando a linguagem Java e o framework JUnit) para resolver o
problema descrito abaixo:
“Nesse exercício, o participante deverá implementar um processador de boletos. O
objetivo desse processador é verificar todos os boletos e, caso o valor da soma de todos
os boletos seja maior que o valor da fatura, então essa fatura deverá ser considerada
como paga. 
Uma fatura contém data, valor total e nome do cliente. Um boleto cóntem código do
boleto, data, e valor pago. O processador de boletos, ao receber uma lista de boletos,
deve então, para cada boleto, criar um "pagamento" associado a essa fatura. Esse
pagamento contém o valor pago, a data, e o tipo do pagamento efetuado (que nesse
caso é "BOLETO").
Como dito anteriormente, caso a soma de todos os boletos ultrapasse o valor da fatura,
a mesma deve ser marcada como "PAGA".
 
Exemplos de processamento:
 
• Fatura de 1.500,00 com 3 boletos no valor de 500,00, 400,00 e 600,00: fatura
marcada como PAGA, e três pagamentos do tipo BOLETO criados
• Fatura de 1.500,00 com 3 boletos no valor de 1000,00, 500,00 e 250,00: fatura
marcada como PAGA, e três pagamento do tipo BOLETO criados
• Fatura de 2.000,00 com 2 boletos no valor de 500,00 e 400,00: fatura não
marcada como PAGA, e dois pagamentos do tipo BOLETO criados” (Aniche,
2012).
(Exercício 7) Seguindo um ciclo Test Driven Development (TDD), desenvolva as
classes necessárias (usando a linguagem Java e o framework JUnit) para resolver o
problema descrito abaixo:
“O participante deverá implementar um filtro de faturas. Uma fatura contém um
código, um valor, uma data, e pertence a um cliente. Um cliente tem um nome, data de
inclusão e um estado. O filtro deverá então, dado uma lista de faturas, remover as que
se encaixam em algum dos critérios abaixo:
 
• Se o valor da fatura for menor que 2000;
• Se o valor da fatura estiver entre 2000 e 2500 e a data for menor ou igual a de
um mês atrás;
• Se o valor da fatura estiver entre 2500 e 3000 e a data de inclusão do cliente for
menor ou igual a 2 meses atrás;
• Se o valor da fatura for maior que 4000 e pertencer a algum estado da região
Sul do Brasil.” (Aniche, 2012).
(Exercício 8) Faça uma classe que receba como entrada um inteiro positivo e responda
se o número é primo ou não. Considere os seguintes casos de teste:(5; “primo”), (49;
“nao eh primo”), (37; “primo”), (10; “nao eh primo”) e (-15; InvalidInputException).
(Exercício 9) Utilize TDD para encontrar as raízes de aX²+bX+c = 0. Projete casos de
teste inicialmente para 2 raízes e uma raiz (classes válidas). Considere classes inválidas
(não é equação de 2º grau). Considere raízes com números complexos.
(Exercício 10) Seguindo um ciclo TDD, desenvolva as classes necessárias (usando a
linguagem Java e o framework JUnit) para resolver o problema descrito abaixo: 
A aproximação para o cálculo do cosseno de um número x (ângulo em radianos) pode
ser dado pela fórmula a seguir:
Considere que: 
– Quanto maior o número de termos maior a precisão, assim deve ser possível
parametrizar o número de termos.
– Crie métodos específicos para calcular a potência e o fatorial.
– Use o método Math.cos() como referência para elaborar os casos de teste para o
cosseno.
– Use como entrada (valor x) valores entre 0 a 6,2.
(Exercício 11) Crie uma classe entidade Contato com os atributos: nome, password, e-
mail, telefone, idade, peso. Crie uma classe chamada ContatoDAO com um método
“salvar()” que recebe como parâmetro um objeto da classe Contato. O método
“salvar()” deve lançar exceções, considerando que:
1. Os campos nome, password e e-mail são obrigatórios.
2. A idade se não for vazia (ou seja, igual a zero) deve estar entre 5 e 99 anos.
3. O peso se não for vazio (ou seja, igual a zero) deve estar entre 1 e 200 kg.
Crie uma exceção para cada um dos possíveis 3 erros, lembrando que todas devem ser
do tipo “checked exceptions”. A lógica do método “salvar()” deve ser implementada.
Crie casos de teste em JUnit para verificar cada um dos possíveis erros.
(Exercício 12) Escreva uma implementação para a estrutura de dados pilha; tal pilha
deve ser capaz de empilhar e desempilhar strings. Considere que:
• Tal pilha possui um tamanho limitado (que deve ser passado como parâmetro no
construtor). 
• Adicione métodos para empilhar, desempilhar e verificar se a pilha está vazia. 
• Crie duas classes de exceção que devem ser do tipo “checked exception”:
PilhaVaziaException e PilhaCheiaException. 
◦ PilhaVaziaException deve ser lançada caso tente desempilhar a pilha sem
elementos.
◦ PilhaCheiaException deve ser lançada caso tente empilhar um elemento na
pilha cheia.
• Implemente casos de teste em JUnit que ilustrem a utilização dos métodos e as
possíveis exceções lançadas.
(Exercício 13) “Nuvem de palavras (em Inglês, word cloud) é uma imagem compostas
de palavras usadas em um texto ou assunto específico no qual o tamanho de cada
palavra indica sua frequência” (Google, 2016). A nuvem de palavras pode ser construída
da seguinte forma: 
1. Transformar o texto original em um array de strings no qual cada elemento do
array é uma palavra. Neste caso, espaços em branco, pontos finais e vírgulas são
desconsiderados.
2. Remover deste array palavras que não são de interesse (estão contidas em uma
lista negra). Exemplos de palavras que poderiam estar em uma lista negra são
artigos, preposições, advérbios, etc. 
3. Contar e armazenar a frequência de cada palavra. 
4. Ordenar, de forma decrescente, as palavras pela frequência.
5. Gerar a imagem dando destaque as palavras com maior frequência.
Seguindo um ciclo Test Driven Development (TDD), desenvolva as classes necessárias
(usando a linguagem Java e o framework JUnit) para resolver o problema descrito
anteriormente. Não precisa gerar a imagem (Passo 5) e assuma que o texto estará
inicialmente em uma String.
Referências
• M. Aniche, “Exercícios utilizados no estudo sobre TDD (SBES 2012)”.
Disponível online em: https://gist.github.com/mauricioaniche/3024328