Você está na página 1de 4

UMC – ACET – SISTEMAS DE INFORMAÇÃO – TESTES DE SOFTWARE – PRÁTICA 3

EXERCITANDO A ELABORAÇÃO DE CASOS DE TESTE

OBJETIVOS:
 Praticar a elaboração, codificação e execução de casos de teste unitário.
 Calcular a complexidade ciclomática de um código e relacionar esta medida com o número de casos
de teste necessários para um código.
INTRODUÇÃO
A Complexidade ciclomática (ou complexidade condicional) é uma métrica de software usada para
indicar a complexidade de um programa de computador. Desenvolvida por Thomas J. McCabe em 1976, ela
mede a quantidade de caminhos de execução independentes a partir de um código fonte.
Essa complexidade é computada através do grafo de fluxo de controle do programa: os nós do
grafo correspondem a grupos indivisíveis de comandos, e uma aresta direcionada conecta dois nós se o
segundo comando pode ser executado imediatamente após o primeiro. A complexidade ciclomática
também pode ser aplicada a funções, módulos, métodos ou classes individuais de um programa.
Uma estratégia de teste de software formulada por McCabe é testar cada caminho independente
de um programa, de forma que a quantidade de casos de teste será a complexidade ciclomática do
programa.
A complexidade ciclomática de uma seção do código fonte é a quantidade de caminhos
independentes pelo código. Por exemplo, se o código fonte contém apenas estruturas sequenciais a
complexidade é 1, já que há somente um caminho válido através do código. Se o código possui somente
uma estrutura de seleção contendo somente uma condição, então há dois caminhos possíveis, aquele
quando a condição é avaliada em verdadeiro, e aquele quando a condição é avaliada em falso.
Matematicamente, a complexidade ciclomática de um programa estruturado é definida com
referência ao grafo direcionado que contém os blocos básicos do programa, com uma aresta entre dois
blocos se o controle pode passar do primeiro para o segundo imediatamente, sem blocos intermediários. A
complexidade então é definida como:
M=E–N+2P
Em que:
M = complexidade ciclomática
E = quantidade de setas (arestas)
N= quantidade de nós
P = quantidade de componentes conectados
Uma formulação alternativa é usar um grafo em que o ponto de saída é conectado ao ponto de
entrada. Nesse caso, o grafo é dito fortemente conectado, e a complexidade ciclomática do programa é
equivalente ao número ciclomático do grafo, definido como: M = E – N + P.
Isso pode ser visto como o cálculo da quantidade de ciclos independentes que existem no grafo,
isto é, os ciclos que não contém outros ciclos embarcados. Notar que, tendo em vista que o ponto de saída
é conectado ao ponto de entrada, há pelo menos um ciclo para cada ponto de saída.
Para um programa único, ou subrotina ou método, P é sempre igual a 1. Entretanto, a
complexidade ciclomática pode ser aplicada a diversos programas ou subprogramas simultaneamente, de
forma que P será a quantidade de programas em questão. Pode-se demonstrar que a complexidade
ciclomática de qualquer programa estruturado com somente um ponto de entrada e um ponto de saída é
igual a quantidade de pontos de decisão – como condicionais de estruturas de seleção ou uma iteração dos
laços das estruturas de repetição – mais um.
A complexidade ciclomática também pode ser estendida para programas com múltiplas saídas,
definida como:
M = - s + 2
Em que:
 = quantidade de pontos de decisão do programa
s = quantidade de pontos de saída
Nesta aula você elaborará uma quantidade de casos de teste para um método de uma classe
CarrinhoDeCompras. A quantidade de casos será determinada pelo valor da complexidade ciclomática do
método testado.
Muitas lojas virtuais possuem um carrinho de compras, que guarda uma lista de itens comprados. A
classe CarrinhoDeCompras possui um método chamado getTotal() para determinar o valor total dos itens
armazenados no carrinho. Um item é modelado por uma classe que possui um produto e uma quantidade
comprada. A classe item possui um método para calcular o valor total do item. Um produto é modelado por
uma classe que possui uma descrição e um valor unitário.
Sua tarefa será elaborar casos de teste para verificar se o método getTotal() da classe
CarrinhoDeCompras possui uma implementação válida. O número de casos de teste deve ser igual à
complexidade ciclomática do método testado.
DESENVOLVIMENTO
1) Inicie o Netbeans e crie um novo projeto de biblioteca de classe Java chamado Teste2.
2) Expanda o nó Pacote de Códigos-fonte do seu projeto e crie um novo pacote chamado modelo.
3) No pacote modelo, crie uma nova classe Java chamada Produto.
4) Edite o código-fonte da classe Produto para ficar como mostrado na figura a seguir. Como sugestão,
use a opção Encapsular campos do menu Refatorar do NetBeans para criar os métodos getters e setters
da classe Produto.

5) Ainda no pacote modelo, crie uma nova classe Java chamada Item.
6) Edite o código-fonte da classe Item para ficar como mostrado na figura a seguir.
7) Faça clique com o botão direito do mouse sobre o nó da classe Item.java na janela Projetos. Selecione
Ferramentas -> Criar testes. Na janela Criar Testes, desmarque as opções Inicializador de Testes,
Finalizador de Testes, Inicializador da Classe de Teste e Finalizador da Classe de Teste. Faça clique sobre
o botão OK. Caso apareça a janela Selecionar Versão do JUnit, selecione JUnit 4.x e depois faça clique
sobre o botão Selecionar.
8) Edite o código-fonte do método testGetValorTotal() da classe ItemTest para ficar como ilustrado na
figura a seguir.

9) Faça clique com o botão direito do mouse sobre o nó ItemTest.java. Selecione Executar arquivo
Shift+F6 e observe o resultado do teste. Você concorda que se um pacote de arroz custa R$ 2,30 então
três pacotes deverão custar R$ 6,90? Elabore outro caso de teste e execute-o. Mostre seu trabalho ao
professor.
10) Faça clique com o botão do mouse sobre o nó modelo, abaixo do nó Pacotes de Códigos-fonte do seu
projeto, e crie uma nova classe Java chamada CarrinhoDeCompras.
11) Edite o código-fonte da classe CarrinhoDeCompras de modo a ficar como na figura a seguir.

12) Agindo de modo semelhante ao do passo 9), crie uma classe de teste para a classe CarrinhoDeCompras.
Edite o código-fonte removendo todos os métodos da classe de teste exceto o construtor e o método
testGetTotal().
13) Edite o código-fonte do método testGetTotal() da classe CarrinhoDeComprasTest para que a classe
fique semelhante ao mostrado na figura a seguir.
14) Execute o teste proposto e veja o resultado. Note que, neste caso de teste, pretendeu-se verificar se o
valor total do carrinho vazio é zero. Será que este único teste é suficiente para garantir que o método
getTotal() é correto? Para justificar sua resposta, calcule a complexidade ciclomática do método
getTotal() e elabore tantos casos de teste quanto for o valor da complexidade ciclomática calculada.
Mostre seu trabalho ao professor.

Você também pode gostar