prof-calebe / source-code-inspection Goto Github PK

1-) Engenharia de Requisitos

As estações de trem freqüentemente fornecem máquinas de vender bilhetes que imprimem um bilhete quando um cliente insere a quantia correta para pagar a passagem. As máquinas mantêm uma soma total da quantidade de dinheiro que coletou durante toda sua operação.

Tipo de Defeito: Ambiguidade
As máquinas que vendem bilhete são atendidas por atendentes. Voce ate pode ter fazer recarga de bihete sozinho numa licenciada, mas vc nunca compra o cartão (bilhete )neste tipo de maquina.

1.2-) Diagrama dos Casos de Uso
Tipo de Defeito: Fato Incorreto
Primeiro insiro o bilhete, depois solicito a quantia, a opção de pagamento e após pago, recebo uma autenticação confirmando o processo. A opção troco teria que ser confirmada no inicio do processo se existe, porque se o processo é concluído e não há troco e o cliente fica sem.

1.3.1-) CSU01 – Inserir dinheiro

Uma quantia de dinheiro é inserida na máquina. É importante ressaltar que essa quantia sempre é representada por uma única nota de papel-moeda.

Tipo de Defeito: Fato Incorreto
O sistema tem que deixar claro se há no troco, se ele só da a opção de dinheiro em uma nota ele tem que me garantir que vou ter meu troco se precisar. Outra opção que seria ideal ter e não há, é o pagamento em cartão de débito, funciona como dinheiro à vista.

1. O Cliente insere uma nota de papel- moeda.

Tipo de Defeito: Fato Incorreto
A primeira opção deveria ser validar o bilhete e assim pedir a forma de pagamento. Feito esse processo voce paga e valida o pagamento.

1. O Sistema adiciona o valor ao saldo disponível.
2. O Sistema informa que a nota de papel- moeda foi aceita.

Tipo de Defeito: Fato Incorreto
Voce paga, depois o sistema deve validar esse pagamento. Confirmado, ai sim o sistema adiciona o valor ao saldo disponível e informa ele, assim finalizar a operação.

1. O Sistema devolve a nota de papel- moeda.

Tipo de Defeito: Fato Incorreto
O sistema teria que validar primeiramente se a nota é verdadeira ou falsa.

1.4 Protótipos > 1.4.1 Tela principal

Tipo de Defeito: Fato Incorreto
Deveria ter a opção de corrigir caso haja necessidade.

2 Projeto Orientado a Objetos > 2.1 Diagrama de Classes Principal

Tipo de Defeito: Ambiguidade
Qual a real necessidade do Iterator no diagrama, possivelmente seria para caso o troco seja numa nota que não exista.

Tipo: Fato incorreto.
Severidade: Alta.
O cliente não pode sempre acertar com a quantidade correta para pagar.

Tipo: Fato incorreto.
Severidade: Média.
O preço do bilhete é quase sempre quebrado, não sei se com apenas uma nota o cliente conseguiria pagar.

classe troco linha 61, o loop do for sera executado apenas uma vez por causa da condição, ou a variavel I deveria sofre decremento ou o valor inicial de I deveria ser alterado.

for (int i = 0; i <= 5; i++)

Classe > TicketMachine
Sistema não informa se saldo é insuficiente.
Categoria: Comissão > Severidade: Alta

Correção:

public String imprimir() throws SaldoInsuficienteException {
        if (saldo < valor) {
            System.out.println("O saldo é insuficiente!");
            throw new SaldoInsuficienteException();
        }
        String result = "**************\n";
        result += " R$ " + saldo + ",00 *\n";
        result += "**************\n";
        return result;
    }

Classe > TicketMachine
Sistema não valida se a nota devolvida foi retirada.
Categoria: Comissão > Severidade: Alta

Correção:

public void inserir(int amount) throws PapelMoedaInvalidaException {
        boolean found = false;
        int note = -1;
        System.out.println("Aguarde. O sistema está validando as notas.");
        for (int i = 0; i < papelMoeda.length && !found; i++) {
            if (papelMoeda[i] == amount) {
                found = true;
            }
            note = i;
        }
        if (!found) {
            while (!found) {
                refund(note);
                System.out.println("Retire a nota não aceita");
                if (note == -1) {
                    found = true;
                } else {
                    note = -1;
                }
            }
            throw new PapelMoedaInvalidaException();
        } else {
            System.out.println("A nota de papel moeda $" + papelMoeda[note] + " foi aceita");
            this.saldo += amount;
            System.out.println("O saldo atual é: " + saldo);
        }
    }
   .
   .
   .
void refund(int indice){
        papelMoeda[indice]--;
    }

classe troco, linha 63 e 66, os returns estão com logica incorreta juntamente com o IF.

@OverRide
public boolean hasNext() {
for (int i = 0; i <= 5; i++) {
if (troco.papeisMoeda[i] = null) {
return false;
}
}
return true;
}

Tipo: Inconsistência.
Severidade: Alta.
Se o cliente inserir a quantidade certa de dinheiro, ele não deveria precisar solicitar troco.

na classe troco linha 44, deveria ter sido utilizado o índice [0].

papeisMoeda[0] = new PapelMoeda(2, count);

Tipo: Inconsistência.
Severidade: Alta.
Faltou o fluxo de exceção quando o sistema verifica o saldo e não precisa devolver o troco, mas exibir uma mensagem que não possui troco.

• Severidade: Média
• Tipo de problema: Inconsistência
• Descrição: O Caso de Uso ‘Solicitar Bilhete’ e ‘Solicitar Troco’ não está de acordo com o seu objetivo, que no final acaba somente mostrando o saldo.

linha 25: O if inicia na posição 1, enquanto o vetor inicia na posição 0, com isso, a primeira posição do vetor é ignorada.

Omissão – na especificação do caso de uso Pós-condição não especifica o saldo total disponível

Tipo: Fato incorreto.
Severidade: Alta.
Porque o sistema exibiria o saldo atual zerado se a nota de papel-moeda não validou. O certo seria aparecer voltar para o passo 1 do Fluxo Principal.

Inicialização – no código apresenta as informações de quantidade porém na documentação não tem esse variável no caso de uso.

linha 25: No lugar do número 1, deveria estar a variável i.

Tipo: ambiguidade
Seveidade: Alta

No parágrafo a frase “As máquinas mantem uma soma total da quantidade de dinheiro” não sabemos se essas informações se trata da soma total das máquinas ou do usuário.

Tipo: Fato incorreto.
Severidade: Baixa.
O sistema pode mostrar a mensagem de aguardo pro cliente enquanto valida a nota papel-moeda inserida.

• Severidade: Alta
• Tipo do problema: Omissão
• Descrição: Não é mostrado um dos atores do sistema, para ver a soma total da quantidade de dinheiro que coletou durante toda a sua operação (no caso um administrador).

Mudar a estrutura de pacotes, retirando a dependência explícita do Mackenzie.

Tipo: Fato incorreto.
Severidade: Alta.
O troco sempre vai ser devolvido mesmo com o valor do bilhete pago corretamente?

Tipo: Fato incorreto.
Severidade: Alta.
O sistema só verifica o saldo no fluxo de inserção de dinheiro.

package br.calebe.ticketmachine.core;

import br.calebe.ticketmachine.exception.PapelMoedaInvalidaException;
import br.calebe.ticketmachine.exception.SaldoInsuficienteException;
import java.util.Iterator;

/**
*Alunos: Guilherme Maoli e Leonardo Portella

• @author Calebe de Paula Bianchini
  */
  public class TicketMachine {

  protected int valor;
  //Desempenho:nao foi criado saldo ALTO
  protected int saldo;
  //Comissao: nao foi criado a classe papelMoeda ALTO
  protected int[] papelMoeda = {2, 5, 10, 20, 50, 100};

  public TicketMachine(int valor) {
  this.valor = valor;
  //Desempenho:nao foi criado saldo ALTO
  //Comissão: deveria ser classe construtor, pois esta chamando o saldo MEDIO
  this.saldo = 0;
  }

  public void inserir(int quantia) throws PapelMoedaInvalidaException {
  boolean achou = false;
  for (int i = 0; i < papelMoeda.length && !achou; i++) {
  //DADOS:valor de papelmoeda deve ser i ALTO
  if (papelMoeda[1] == quantia) {
  achou = true;
  }
  }
  if (!achou) {
  throw new PapelMoedaInvalidaException();
  }
  //Desempenho:nao foi criado saldo ALTO
  this.saldo += quantia;
  }
  //Desempenho:nao foi criado saldo ALTO

  public int getSaldo() {
  return saldo;
  }
  //Excesso: nao foi criado Iterator ALTO
  //A função "getTroco()" sempre retorna "null" portanto não é necessaria BAIXO
  public Iterator getTroco() {
  return null;
  }
  //Comissão: desnecessario a consulta de saldo nesse caso BAIXO
  public String imprimir() throws SaldoInsuficienteException {
  //Desempenho:nao foi criado saldo ALTO
  if (saldo < valor) {
  throw new SaldoInsuficienteException();
  }
  String result = "\n";
  result += " R$ " + saldo + ",00 ****\n";
  result += "***\n";
  return result;
  }
  }

Tipo: Ambiguidade.
Severidade: Alta.
O sistema devolve a quantidade do saldo do troco e não total.

linha 25: Não é atribuído valor a variável “quantia”, com isso, não da para ser compara a uma posição x do vetor

Tipo: Inconsistência.
Severidade: Alta.
O que acontece se a máquina parar de funcionar quando o cliente solicita troco, ele vai ficar solicitando troco para sempre, sem solicitar manutenção do técnico.

Tipo: Informação estranha.
Severidade: Média.
Não é apenas uma quantia de dinheiro, seria a quantidade aproximada para pagar o bilhete.

Tipo: Informação estranha.
Severidade: Alta.
As estações de trem não podem fornecer frequentemente as máquinas de vender bilhetes, se pararem de fornecer a operação do metro acaba.

Tipo: Omissão.
Severidade: Alta.
Falta regra de negócios do tipo: se o cliente não inserir a quantidade correta de dinheiro, deveria aparecer um aviso na máquina.

Fato incorreto – O sistema adiciona o valor da nota ao saldo disponível mais não sabemos o saldo

Comissão – No código temos uma função “saldoInsuficiente” quanto o cliente tenta retirar o seu bilhete após solicita-lo. Na documentação dos casos de uso não temos a solicitação de saldo insuficiente.

linha 43: Neste método o if não funcionará, pois o saldo foi somado à quantia anteriormente, no qual saldo tinha um valor inteiro e quantia era null.

linha 32: Já que não foi atribuído um valor à variável “quantia”, a variável “saldo” também não poderá receber o valor da mesma.

Tipo: Omissão.
Severidade: Alta.
Está faltando um ator Técnico caso a máquina pare de funcionar ou não devolva o troco.

Tipo: Inconsistência.
Severidade: Alta.
Cadê o Fluxo de exceção caso o cliente não insira a quantidade correta de dinheiro.

Tipo: Omissão.
Seriedade: Alta.
O que acontece se o cliente não fornece a quantidade correta para pagar?

Tipo: Omissão.
Severidade: Alta.
Durante toda sua operação no dia ela vai manter a soma total da quantidade de dinheiro que coletou? Então, depois da primeira venda no dia as pessoas seguintes vão poder imprimir o bilhete sem pagar, porque a soma total da quantidade de dinheiro está coletada

package br.calebe.ticketmachine.core;

import java.util.Iterator;

/**
*Alunos: Guilherme Maoli e Leonardo Portella

• @author Calebe de Paula Bianchini
  */
  class Troco {

  protected PapelMoeda[] papeisMoeda;

  public Troco(int valor) {
  papeisMoeda = new PapelMoeda[6];
  int count = 0;
  //O loop em questão é infinito pois a variavel que o define não é alterada dentro do proprio laço ALTO
  while (valor % 100 != 0) {
  count++;
  }
  papeisMoeda[5] = new PapelMoeda(100, count);
  count = 0;
  //O loop em questão é infinito pois a variavel que o define não é alterada dentro do proprio laço ALTO
  while (valor % 50 != 0) {
  count++;
  }
  papeisMoeda[4] = new PapelMoeda(50, count);
  count = 0;
  //O loop em questão é infinito pois a variavel que o define não é alterada dentro do proprio laço ALTO
  while (valor % 20 != 0) {
  count++;
  }
  papeisMoeda[3] = new PapelMoeda(20, count);
  count = 0;
  //O loop em questão é infinito pois a variavel que o define não é alterada dentro do proprio laço ALTO
  while (valor % 10 != 0) {
  count++;
  }
  papeisMoeda[2] = new PapelMoeda(10, count);
  count = 0;
  //O loop em questão é infinito pois a variavel que o define não é alterada dentro do proprio laço ALTO
  while (valor % 5 != 0) {
  count++;
  }
  papeisMoeda[1] = new PapelMoeda(5, count);
  count = 0;
  while (valor % 2 != 0) {
  count++;
  }
  papeisMoeda[1] = new PapelMoeda(2, count);
  }

  public Iterator getIterator() {
  return new TrocoIterator(this);
  }

  class TrocoIterator implements Iterator {

   protected Troco troco;
  
   public TrocoIterator(Troco troco) {
       this.troco = troco;
   }
  
   @Override
   public boolean hasNext() {
       for (int i = 6; i >= 0; i++) {
           **//O codigo nunca entrara no laço for pois a variavel RET sempre sera NULL ALTO**
           if (troco.papeisMoeda[i] != null) {
               return true;
           }
       }
       return false;
   }
  
   @Override
   public PapelMoeda next() {
       PapelMoeda ret = null;
       for (int i = 6; i >= 0 && ret != null; i++) {
           if (troco.papeisMoeda[i] != null) {
               ret = troco.papeisMoeda[i];
               troco.papeisMoeda[i] = null;
           }
       }
       return ret;
   }
  
   @Override
   **//O metodo "remove()" não é necessário pois apenas chama um outro metodo BAIXO**
   public void remove() {
       next();
   }
  

  }
  }

Computação – GetTroco deveria apresenta o valor do troco, mais está apresentando “null” no retorno

classe troco, linha 70, método sem proposito e implementado de maneira incorreta.
o método deveria ser apagado.

Ambiguidade – Na primeira linha as informações “As estações de trem frequentemente fornecem maquinas” essa informação não há necessidade pois as maquinas já são para as estações de trem.

linha 40: O método retorna nulo independente de ter troco ou não.

Desempenho – Na class troco o laço while que realizado a devolução do troco está com a divisão erra, pois ele apresenta a divisão por 100% !=0 ele conta caso a divisão for 0 ele vai ficar infinitamente no laço.

O estímulo de criação é representado com linha seccionada, sendo que o correto seria com linha contínua.

package br.calebe.ticketmachine.core;

/**
*Alunos: Guilherme Maoli e Leonardo Portella

• @author Calebe de Paula Bianchini
  */
  public class PapelMoeda {
  //Comissao: no lugar do protected deveria ser public - BAIXO
  protected int valor;
  protected int quantidade;
  //Construtor - BAIXO
  public PapelMoeda(int valor, int quantidade) {
  this.valor = valor;
  this.quantidade = quantidade;
  }
  //Comissao: não foi criado setValor - ALTO
  public int getValor() {
  return valor;
  }
  //Comissao: não foi criado setQuantidade - ALTO
  public int getQuantidade() {
  return quantidade;
  }
  }

classe troco linha 82, o método chama o Next() porem a logica do next faz com que ele sempre retorne null, e não realizando nada não importa a situação.