Análise do Valor Limite: O que É e Como Aplicar em Testes

A análise do valor limite (Boundary Value Analysis, BVA) é uma técnica de teste de software caixa-preta que verifica os extremos das partições de entrada — mínimo, máximo e seus vizinhos imediatos —, usada para detectar defeitos que se concentram nas bordas dos intervalos que um programa aceita.

• O que é a análise do valor limite?
• Por que testar os valores limite?
• Como funciona a BVA de 2 valores e de 3 valores?
• Como aplicar a análise do valor limite em 5 passos?
• Exemplo prático de análise do valor limite em código

O que é a análise do valor limite?

A análise do valor limite é uma técnica de teste de caixa-preta que deriva casos de teste dos valores situados nas fronteiras das partições de entrada: o menor valor aceito, o maior valor aceito e os valores imediatamente fora desse intervalo. Também é chamada de teste de limite ou teste de borda.

A técnica parte de uma observação prática: os erros mais críticos tendem a ocorrer quando os dados de entrada se aproximam dos limites do que um programa consegue manipular — o dia 31 de um mês, o valor máximo de uma transação, o índice final de um array. Condições como > escritas no lugar de >= passam despercebidas em valores centrais, mas falham exatamente na borda.

Por isso, a análise do valor limite é normalmente aplicada como extensão do particionamento de equivalência: primeiro divide-se o domínio de entrada em partições com comportamento esperado equivalente; depois, testam-se as fronteiras entre essas partições, em vez de valores aleatórios no meio de cada uma.

Por que testar os valores limite?

Testar os valores limite concentra o esforço de teste onde a probabilidade de defeito é maior, reduzindo o custo de encontrar bugs críticos antes da produção. O impacto econômico de não fazer isso é bem documentado.

O estudo The Economic Impacts of Inadequate Infrastructure for Software Testing, publicado pelo NIST (National Institute of Standards and Technology) em 2002, estimou que defeitos de software custavam US$59,5 bilhões por ano à economia dos EUA — cerca de 0,6$ 22,2 bilhões poderiam ser eliminados com melhor infraestrutura de testes e identificação mais precoce dos erros.

O problema só cresceu: o relatório Cost of Poor Software Quality in the US: A 2022 Report, do CISQ (Consortium for Information & Software Quality), estimou o custo da baixa qualidade de software nos EUA em pelo menos US$2,41 trilhões em 2022, com um débito técnico acumulado de cerca de US$ 1,52 trilhão.

Nesse cenário, a análise do valor limite entrega três benefícios diretos dentro de uma estratégia de testes de software:

• Identificação de bugs críticos: os limites concentram erros de comparação, estouro e validação.
• Melhoria da qualidade: o software passa a ser verificado nas situações extremas, não só no caminho feliz.
• Economia de tempo e recursos: poucos valores bem escolhidos cobrem mais risco do que muitos valores aleatórios.

Como funciona a BVA de 2 valores e de 3 valores?

O syllabus ISTQB CTFL v4.0, do ISTQB (International Software Testing Qualifications Board), define duas variantes da técnica: a BVA de 2 valores, que testa cada limite e o vizinho imediato da partição adjacente, e a BVA de 3 valores, que testa cada limite e os vizinhos dos dois lados. A escolha depende do risco do sistema sob teste.

Um exemplo concreto: se um campo aceita idades de 18 a 65 anos, a BVA de 2 valores testa 17, 18, 65 e 66; a BVA de 3 valores acrescenta 19 e 64. O white paper oficial do ISTQB sobre Boundary Value Analysis detalha os itens de cobertura de cada variante e recomenda a versão de 3 valores quando as consequências de um defeito na borda são severas.

Como aplicar a análise do valor limite em 5 passos?

A aplicação da análise do valor limite segue um fluxo curto e repetível, que funciona tanto em testes manuais quanto automatizados:

1. Identifique os valores limite relevantes do sistema: limites superiores e inferiores de intervalos numéricos, datas, valores monetários, tamanhos de campo e índices de coleções.
2. Crie casos de teste focados nesses limites e em seus vizinhos. Em um aplicativo financeiro, por exemplo, teste valores no limite máximo de uma transação, imediatamente abaixo e imediatamente acima.
3. Execute os testes cobrindo todos os valores mapeados, registre os resultados e observe qualquer comportamento anormal, mensagem de erro inesperada ou falha silenciosa.
4. Corrija e repita: ao encontrar defeitos, ajuste o código e reexecute os casos até que todos os limites sejam tratados corretamente.
5. Automatize sempre que possível, incorporando os casos de limite à suíte de regressão para garantir cobertura consistente a cada mudança no código.

Exemplo prático de análise do valor limite em código

O exemplo clássico de valor limite é a divisão: o denominador 0 é a borda exata entre entradas válidas e inválidas, e é nela que o programa quebra se não houver tratamento. Abaixo, o mesmo caso em quatro linguagens.

Exemplo em C

Utilizando a linguagem de programação C:

#include <stdio.h>
#include <stdbool.h>

// Função para dividir dois números inteiros
double divide(int numerator, int denominator) {
    if (denominator == 0) {
        // Evitar divisão por zero
        return -1.0; // Valor de erro
    }
    return (double)numerator / denominator;
}

int main() {
    // Testando a função divide com análise do valor limite
    int testCases[5][2] = {
        {10, 2},    // Teste válido
        {5, 0},     // Erro de divisão por zero
        {0, 0},     // Erro de divisão por zero
        {-7, 3},    // Teste válido
        {100, 50}   // Teste válido
    };

    for (int i = 0; i < 5; i++) {
        int numerator = testCases[i][0];
        int denominator = testCases[i][1];

        printf("Teste %d: ", i + 1);

        if (numerator == 0 || denominator == 0) {
            printf("Erro de divisão por zero.\n");
        } else {
            double result = divide(numerator, denominator);
            printf("%d / %d = %.2f\n", numerator, denominator, result);
        }
    }

    return 0;
}

Neste código, a função divide aceita dois números inteiros, numerator e denominator, e retorna o resultado da divisão. A função verifica se o denominator é zero — o valor limite — para evitar uma divisão por zero, retornando um valor de erro (-1.0) nesse caso.

Os casos de teste cobrem a borda e seus dois lados:

• Teste 1: divisão válida (10 / 2 = 5.00)
• Teste 2: erro de divisão por zero
• Teste 3: erro de divisão por zero
• Teste 4: divisão válida (-7 / 3 = -2.33)
• Teste 5: divisão válida (100 / 50 = 2.00)

Exemplo em Java

Na linguagem Java, o valor limite é tratado lançando uma exceção ArithmeticException:

public class DivideExample {
    public static double divide(int numerator, int denominator) {
        if (denominator == 0) {
            throw new ArithmeticException("Erro de divisão por zero");
        }
        return (double) numerator / denominator;
    }

    public static void main(String[] args) {
        int[] numerators = {10, 5, 0, -7, 100};
        int[] denominators = {2, 0, 0, 3, 50};

        for (int i = 0; i < numerators.length; i++) {
            int numerator = numerators[i];
            int denominator = denominators[i];
            try {
                double result = divide(numerator, denominator);
                System.out.println("Resultado: " + numerator + " / " + denominator + " = " + result);
            } catch (ArithmeticException e) {
                System.out.println(e.getMessage());
            }
        }
    }
}

Exemplo em JavaScript

Em JavaScript, o mesmo padrão usa throw e try/catch:

function divide(numerator, denominator) {
  if (denominator === 0) {
    throw new Error('Erro de divisão por zero')
  }
  return numerator / denominator
}

const numerators = [10, 5, 0, -7, 100]
const denominators = [2, 0, 0, 3, 50]

for (let i = 0; i < numerators.length; i++) {
  const numerator = numerators[i]
  const denominator = denominators[i]
  try {
    const result = divide(numerator, denominator)
    console.log(`Resultado: ${numerator} / ${denominator} = ${result}`)
  } catch (error) {
    console.log(error.message)
  }
}

Exemplo em Python

Utilizando a linguagem de programação Python:

def divide(numerator, denominator):
    if denominator == 0:
        raise ZeroDivisionError("Erro de divisão por zero")
    return numerator / denominator

numerators = [10, 5, 0, -7, 100]
denominators = [2, 0, 0, 3, 50]

for i in range(len(numerators)):
    numerator = numerators[i]
    denominator = denominators[i]
    try:
        result = divide(numerator, denominator)
        print(f"Resultado: {numerator} / {denominator} = {result}")
    except ZeroDivisionError as e:
        print(e)

Conclusão

A análise do valor limite é uma das técnicas com melhor relação custo-benefício do teste de software: com meia dúzia de valores bem escolhidos por intervalo, ela captura a classe de defeitos que mais escapa para produção — os erros de borda. Aqui no CodeCrush, a recomendação prática é direta: nunca use a BVA como método único, mas trate-a como item obrigatório de qualquer suíte de testes, junto do particionamento de equivalência, e automatize os casos de limite para que cada mudança no código continue sendo verificada exatamente onde o software costuma quebrar.