Complexidade ciclomática em testes de software com exemplos

Qual é a complexidade ciclomática de McCabe?

Complexidade Ciclomática em Teste de Software é uma métrica de teste usada para medir a complexidade de um programa de software. É uma medida quantitativa de caminhos independentes no código-fonte de um programa de software. A complexidade ciclomática pode ser calculada usando gráficos de fluxo de controle ou em relação a funções, módulos, métodos ou classes dentro de um programa de software.

Caminho independente é definido como um caminho que possui pelo menos uma aresta que não foi percorrida antes em nenhum outro caminho.

Esta métrica foi desenvolvida por Thomas J. McCabe em 1976 e é baseada em uma representação do fluxo de controle do programa. O fluxo de controle descreve um programa como um gráfico que consiste em nós e arestas.

No gráfico, os nós representam tarefas de processamento enquanto as arestas representam o fluxo de controle entre os nós.

Notação de gráfico de fluxo para um programa

A notação Flow Graph para um programa define vários nós conectados pelas arestas. Abaixo estão diagramas de fluxo para instruções como if-else, While, Until e sequência normal de fluxo.

Como calcular a complexidade ciclomática

Representação matemática:

Matematicamente, é um conjunto de caminhos independentes através do diagrama gráfico. Code A complexidade do programa pode ser definida usando a fórmula –

V(G) = E - N + 2

Onde,

E – Número de arestas

N – Número de nós

V (G) = P + 1

Onde P = Número de nós predicados (nó que contém condição)

Exemplo -

i = 0;
n=4; //N-Number of nodes present in the graph

while (i<n-1) do
j = i + 1;

while (j<n) do

if A[i]<A[j] then
swap(A[i], A[j]);

end do;
j=j+1;

end do;

O gráfico de fluxo para este programa será

Computando matematicamente,

• V(G) = 9 – 7 + 2 = 4
• V(G) = 3 + 1 = 4 (os nós de condição são 1,2 e 3 nós)

Conjunto básico, os quatro caminhos de execução independentes:

• 1, 7
• 1, 2, 6, 1, 7
• 1, 2, 3, 4, 5, 2, 6, 1, 7
• 1, 2, 3, 5, 2, 6, 1, 7

Propriedades da Complexidade Ciclomática

A seguir estão as propriedades da complexidade ciclomática:

1. V (G) é o número máximo de caminhos independentes no gráfico
2. V(G) >=1
3. G terá um caminho se V (G) = 1
4. Uma diretriz comumente utilizada é manter V(G) em 10 ou menos para um único módulo.

Como essa métrica é útil para testes de software

O teste de caminho básico é uma técnica de caixa branca que garante a execução de pelo menos uma instrução durante o teste. Ele verifica cada caminho linearmente independente através do programa, o que significa que O número de casos de teste necessários é igual à complexidade ciclomática do programa..

Esta métrica é útil devido às propriedades da complexidade ciclomática (M) –

1. M pode ser o número de casos de teste para obter cobertura de filial (limite superior)
2. M pode ser o número de caminhos através dos gráficos. (Limite inferior)

Considere este exemplo -

If (Condition 1)
Statement 1

Else
Statement 2

If (Condition 2)
Statement 3

Else
Statement 4

A complexidade ciclomática para este programa será 8-7+2=3.

Como a complexidade foi calculada como 3, três casos de teste são necessários para a cobertura completa do caminho do exemplo acima.

Passos a seguir

As etapas a seguir devem ser seguidas para calcular a complexidade do Ciclomático e projetar casos de teste.

Etapa 1 – Construção de gráfico com nós e arestas do código

Etapa 2 – Identificação de caminhos independentes

Etapa 3 – Cálculo da Complexidade Ciclomática

Etapa 4 – Desenho de Casos de Teste

Uma vez formado o conjunto básico, CASOS DE TESTE deve ser escrito para executar todos os caminhos.

Mais sobre V (G)

A complexidade ciclomática pode ser calculada manualmente se o programa for pequeno. Ferramentas automatizadas precisam ser usadas se o programa for muito complexo, pois envolve mais gráficos de fluxo. Com base no número de complexidade, a equipe pode concluir sobre as ações que precisam ser tomadas para mensuração.

A tabela a seguir fornece uma visão geral do número de complexidade e o significado correspondente de v(G):

Ferramentas para calcular a complexidade ciclomática

Muitas ferramentas estão disponíveis para determinar a complexidade do aplicativo. Algumas ferramentas de cálculo de complexidade são utilizadas para tecnologias específicas. A complexidade pode ser encontrada pelo número de pontos de decisão em um programa. Os pontos de decisão são instruções if, for, for-each, while, do, catch, case em um código-fonte.

Exemplos de ferramentas são

• OCLint – Analisador de código estático para C e linguagens relacionadas
• SonarQube – Apresenta relatórios sobre a complexidade ciclomática e cognitiva em mais de 25 idiomas.
• Visual Studio Code Métricas – Análise de complexidade ciclomática integrada para assemblies .NET
• Radon e Lizard – Analisadores de complexidade de linha de comando para Python e para projetos multilíngues, respectivamente
• Métricas – Encontre métricas em Java aplicativos relacionados

Usos da Complexidade Ciclomática

A Complexidade Ciclomática pode ser muito útil em

• Ajuda desenvolvedores e testadores a determinar execuções de caminhos independentes
• Os desenvolvedores podem garantir que todos os caminhos foram testados pelo menos uma vez.
• Ajuda-nos a focar mais nos caminhos descobertos
• Melhore a cobertura do código em Engenharia de Software
• Avalie o risco associado ao aplicativo ou programa
• Usar essas métricas no início do ciclo reduz mais riscos do programa

Como reduzir a complexidade ciclomática

Um número de complexidade elevado é um sinal, não um veredito. Quatro refatorações são responsáveis ​​pela maior parte da redução alcançável na prática.

• Extracmétodo t. Mover uma ramificação para sua própria função divide a complexidade entre dois módulos. O total em todo o sistema permanece inalterado, mas cada unidade torna-se testável independentemente.
• Substitua uma cadeia condicional por uma pesquisa. Uma longa sequência de instruções if-else-if testando a mesma variável se transforma em um mapa ou um switch, que condensa muitos pontos de decisão em um só.
• Utilize cláusulas de guarda. Retornar um valor inválido antecipadamente elimina o aninhamento criado por um único bloco if-else grande, sem alterar o comportamento.
• Substitua condicionais por polimorfismo. Quando uma condição depende de um tipo, mover cada ramo para sua própria classe remove a decisão por completo.

Antes, com V(G) = 4:

if (user != null) {
    if (user.isActive()) {
        if (user.hasRole("admin")) {
            return grantAccess();
        }
    }
}
return denyAccess();

Depois, com o mesmo comportamento e o ninho removido:

if (user == null) return denyAccess();
if (!user.isActive()) return denyAccess();
if (!user.hasRole("admin")) return denyAccess();
return grantAccess();

Uma ressalva em relação à métrica. A complexidade ciclomática contabiliza decisões, não dificuldade. Uma instrução switch com vinte casos simples obtém uma pontuação de 21, mas é fácil de ler, enquanto um bloco profundamente aninhado com pontuação 8 pode ser muito mais difícil de entender. Use o número para encontrar candidatos para revisão, não como um alvo a ser explorado.

Perguntas Frequentes