Quando falamos sobre qualidade de software, um dos primeiros assuntos que surgem é a criação de testes automatizados. Entretanto, existe uma pergunta que muitas equipes deixam de fazer: os testes realmente estão exercitando as partes mais importantes do sistema?

Em projetos Delphi isso é ainda mais relevante. Grande parte das aplicações corporativas desenvolvidas com a linguagem possui anos de evolução, milhares de linhas de código e regras de negócio extremamente complexas. Sistemas fiscais, ERPs, aplicações financeiras e integrações governamentais normalmente acumulam conhecimento de negócio ao longo de décadas, tornando qualquer alteração um potencial risco.

É justamente nesse cenário que o Code Coverage se torna uma ferramenta valiosa. Ele permite medir quais partes do código foram efetivamente executadas durante os testes automatizados, fornecendo uma visão objetiva sobre o nível de proteção existente no sistema.

Neste artigo veremos o que é cobertura de código, por que ela é importante, como implementá-la em Delphi utilizando o Delphi Code Coverage e o Delphi Code Coverage Wizard Plus, além de entender como integrar os resultados ao SonarQube para acompanhar a qualidade do projeto ao longo do tempo.

O que é Code Coverage

Code Coverage, ou cobertura de código, é uma métrica utilizada para indicar qual percentual do código-fonte foi executado durante a execução dos testes automatizados.

Em termos simples, a ferramenta monitora quais linhas foram executadas e gera um relatório mostrando quais partes do sistema estão cobertas por testes e quais ainda permanecem sem validação automatizada.

Imagine um método simples:

function Somar(A, B: Double): Double;
begin
  Result := A + B;
end;

Se um teste automatizado executar esse método, todas as linhas serão consideradas cobertas. Caso nenhum teste invoque a função, a cobertura será zero.

Embora pareça simples, essa informação possui enorme valor em sistemas corporativos. Ela permite identificar rapidamente áreas críticas que ainda não possuem testes e que podem representar riscos durante futuras manutenções.

O Que Code Coverage Não É

Um erro muito comum é acreditar que cobertura elevada significa software sem defeitos, na prática, cobertura mede execução e não qualidade dos testes, considere o seguinte exemplo:

procedure TestarCalculo;
begin
  Calculadora.CalcularImposto(1000);
end;

O método foi executado e será contabilizado pela ferramenta de cobertura. Entretanto, o teste não verificou se o valor calculado está correto, isso significa que é perfeitamente possível possuir 90% de cobertura e ainda assim ter uma suíte de testes de baixa qualidade. A cobertura deve ser utilizada como um indicador complementar, ela ajuda a identificar o que está sendo executado, mas não substitui a necessidade de criar testes bem elaborados que validem corretamente o comportamento do sistema.

Por Que Utilizar Cobertura de Código em Projetos Delphi

Projetos Delphi frequentemente possuem características que tornam a cobertura de código especialmente importante.

Muitos sistemas possuem mais de dez anos de evolução, passaram por diversos desenvolvedores e acumulam regras de negócio que nem sempre estão documentadas adequadamente. Em muitos casos, o código funciona porque ninguém ousou alterá-lo nos últimos anos.

Quando a equipe decide modernizar uma aplicação, criar APIs ou realizar refatorações, surge um problema: como saber se uma alteração não afetará outras funcionalidades?

A cobertura de código ajuda justamente nesse processo. Ao identificar quais partes do sistema são exercitadas pelos testes, ela oferece maior confiança para evoluir a aplicação sem introduzir regressões.

Além disso, a cobertura permite acompanhar a maturidade da suíte de testes ao longo do tempo. Em vez de depender apenas da percepção da equipe, torna-se possível utilizar métricas objetivas para avaliar a evolução da qualidade do projeto.

Ferramentas Utilizadas

Atualmente a combinação mais comum no ecossistema Delphi envolve três componentes principais.

• O primeiro deles é o DUnitX, framework de testes automatizados amplamente utilizado pela comunidade Delphi.
• O segundo é o Delphi Code Coverage, ferramenta open source responsável por monitorar a execução do código e gerar relatórios de cobertura.
• Por fim, temos o Delphi Code Coverage Wizard Plus, um plugin disponível através do GetIt que simplifica significativamente a configuração da ferramenta dentro da IDE.

Essa combinação permite implementar cobertura de código sem grandes dificuldades e com integração relativamente simples aos processos modernos de desenvolvimento.

Instalando o Delphi Code Coverage Wizard Plus

A forma mais simples de começar é utilizando o Delphi Code Coverage Wizard Plus.

Abra o Delphi e acesse:

Tools → GetIt Package Manager

Pesquise por:

Delphi Code Coverage Wizard Plus

Após a instalação, reinicie a IDE.

O Wizard adiciona assistentes que automatizam boa parte da configuração necessária para utilização do Delphi Code Coverage, reduzindo significativamente a complexidade inicial.

Preparando o Projeto

Antes de executar a análise de cobertura, é necessário garantir que o projeto esteja configurado corretamente.

O passo mais importante é habilitar a geração detalhada do arquivo MAP.

Abra:

Project Options → Linking

Configure:

Map file = Detailed

O arquivo MAP é utilizado pelo Delphi Code Coverage para correlacionar os endereços executados durante os testes com o código-fonte da aplicação.

Sem essa configuração a ferramenta não conseguirá produzir relatórios precisos.

Criando Testes com DUnitX

A cobertura de código depende da existência de testes automatizados.

Um exemplo simples utilizando DUnitX seria:

[TestFixture]
TCalculadoraTests = class
public
  [Test]
  procedure Somar_DeveRetornarResultadoCorreto;
end;

procedure TCalculadoraTests.Somar_DeveRetornarResultadoCorreto;
begin
  Assert.AreEqual(
    30,
    Calculadora.Somar(10,20)
  );
end;

Quanto mais regras de negócio forem exercitadas pelos testes, maior será a cobertura obtida.

O foco deve estar principalmente em regras críticas, cálculos, integrações e componentes reutilizáveis.

Executando a Análise

Com os testes implementados e o projeto configurado, o próximo passo é executar a análise de cobertura.

O Delphi Code Coverage monitora a execução da aplicação durante os testes e gera relatórios contendo informações detalhadas sobre cada unidade analisada.

Dependendo da configuração escolhida, os resultados podem ser exportados em formatos HTML, XML e outros formatos compatíveis com ferramentas de integração contínua.

O relatório HTML costuma ser o mais utilizado durante o desenvolvimento, pois permite visualizar facilmente quais linhas foram executadas e quais permanecem sem cobertura.

Interpretando os Resultados

Uma das armadilhas mais comuns é perseguir 100% de cobertura como objetivo principal.

Na prática, esse número nem sempre é necessário ou desejável.

Existem trechos de código cuja cobertura pode trazer pouco retorno, como propriedades simples, getters, setters ou código gerado automaticamente.

Por outro lado, áreas críticas do sistema devem receber atenção especial. Regras tributárias, cálculos financeiros, integrações bancárias, emissão de documentos fiscais e processos de negócio sensíveis normalmente justificam índices de cobertura significativamente maiores.

Em muitos projetos corporativos, uma cobertura entre 60% e 80% das regras de negócio já representa um excelente resultado.

Integrando com SonarQube

Se você já utiliza SonarQube para análise estática de código Delphi, adicionar cobertura é um passo natural.

O fluxo normalmente segue o seguinte processo:

DUnitX
   ↓
Delphi Code Coverage
   ↓
Relatório XML
   ↓
SonarQube

Após a importação dos resultados, o SonarQube passa a exibir a cobertura juntamente com outras métricas importantes, como complexidade ciclomática, duplicação de código, vulnerabilidades e code smells.

Isso permite que a equipe acompanhe a evolução da qualidade do projeto através de um único painel centralizado.

Além disso, é possível criar Quality Gates exigindo uma cobertura mínima para aprovação de novas alterações.

Cobertura em Projetos Legados

Uma dúvida bastante comum é se vale a pena implementar cobertura em sistemas legados, a resposta normalmente é sim, entretanto, tentar cobrir todo o sistema de uma única vez costuma ser um erro.

A estratégia mais eficiente é identificar os módulos mais críticos e começar por eles. Cada nova funcionalidade ou correção pode ser acompanhada pela criação de novos testes, aumentando gradualmente a cobertura da aplicação.

Com o passar do tempo, a equipe constrói uma rede de proteção que reduz significativamente o risco de regressões.

Configurando o Delphi Code Coverage Wizard Plus Passo a Passo

Embora o Delphi Code Coverage possa ser utilizado diretamente pela linha de comando, a forma mais simples de começar é utilizando o Delphi Code Coverage Wizard Plus. O plugin foi criado para reduzir a complexidade da configuração inicial e automatizar a geração dos arquivos necessários para execução da cobertura.

Após instalar o Wizard através do GetIt Package Manager, novas opções relacionadas ao Code Coverage passam a ficar disponíveis na IDE do Delphi.

O primeiro passo consiste em abrir o projeto de testes criado com DUnitX. Embora tecnicamente seja possível executar cobertura em qualquer aplicação Delphi, a utilização mais comum ocorre em projetos de testes automatizados.

Antes de utilizar o Wizard, verifique se o projeto está configurado para gerar o arquivo MAP detalhado. Essa configuração pode ser encontrada em:

Project Options → Linking → Map File

O valor deve ser configurado como:

Detailed

Sem essa configuração o Delphi Code Coverage não conseguirá associar corretamente os endereços executados ao código-fonte da aplicação.

Com o projeto devidamente configurado, execute uma compilação completa para garantir que todos os arquivos necessários sejam gerados, a partir desse momento o Wizard poderá ser utilizado para criar a configuração inicial da análise, durante a configuração, alguns pontos merecem atenção especial.

O primeiro deles é a seleção das unidades que serão monitoradas. Uma prática comum entre equipes iniciantes é tentar monitorar absolutamente tudo que faz parte do projeto. Embora isso pareça interessante inicialmente, o resultado normalmente é um relatório extremamente poluído, o ideal é concentrar a análise nas unidades que realmente contêm regras de negócio. Em um ERP, por exemplo, normalmente faz sentido monitorar camadas como:

Model
Business
Service
Controller
Repository
Core

Por outro lado, geralmente não existe ganho significativo em monitorar:

Forms
Frames
DataModules simples
Bibliotecas de terceiros
RTL
VCL
FMX

Outro ponto importante é definir o diretório onde os relatórios serão gerados. Em equipes que utilizam integração contínua, é recomendável criar uma pasta específica para artefatos de qualidade, permitindo que os relatórios sejam posteriormente publicados em servidores de build ou enviados para ferramentas como SonarQube.

Após concluir o assistente, o Wizard gera automaticamente os arquivos de configuração necessários para execução do Delphi Code Coverage. Dependendo da versão utilizada, esses arquivos podem incluir parâmetros para geração de relatórios HTML, XML e outros formatos suportados pela ferramenta.

Uma das maiores vantagens do Wizard é justamente eliminar a necessidade de memorizar todos os parâmetros da linha de comando, permitindo que o desenvolvedor comece rapidamente a trabalhar com cobertura de código sem precisar estudar toda a estrutura interna da ferramenta.

Após a geração da configuração, basta executar os testes normalmente e abrir o relatório HTML produzido. O relatório destacará visualmente as linhas cobertas e não cobertas, facilitando a identificação de áreas que ainda precisam receber novos testes.

Utilizando o Delphi Code Coverage Pela Linha de Comando

Embora o Wizard seja extremamente conveniente para uso local, muitos ambientes corporativos utilizam integração contínua e processos automatizados de build. Nesses cenários, a execução pela linha de comando torna-se praticamente obrigatória.

A principal vantagem da linha de comando é permitir que a cobertura seja executada automaticamente em pipelines do GitHub Actions, Jenkins, Azure DevOps, TeamCity ou qualquer outra ferramenta de automação.

O fluxo básico de execução envolve três etapas principais.

Primeiramente, o projeto deve ser compilado gerando o arquivo executável e o arquivo MAP detalhado.

Em seguida, os testes automatizados são executados através do Delphi Code Coverage.

Por fim, a ferramenta gera os relatórios contendo os resultados da análise.

Uma execução típica pode ser semelhante a:

CodeCoverage.exe ^
  -e MeuProjetoTests.exe ^
  -m MeuProjetoTests.map ^
  -uf ".\Source" ^
  -od ".\Coverage"

Os parâmetros mais utilizados são:

Em projetos maiores é comum a utilização de arquivos de configuração para evitar linhas de comando excessivamente longas e facilitar a manutenção do processo.

Após a execução, a ferramenta gera relatórios detalhados contendo informações sobre cobertura por unidade, classe e método.

Um exemplo simplificado do resultado pode ser:

ClienteService.pas

Linhas Cobertas: 180
Linhas Não Cobertas: 45

Cobertura: 80%

Além do formato HTML, utilizado para análise visual pelos desenvolvedores, também é possível gerar formatos destinados à integração com outras ferramentas.

Quando o objetivo é integrar com SonarQube, normalmente utiliza-se a geração de relatórios XML que posteriormente serão consumidos durante a execução do scanner.

Em ambientes de integração contínua, o fluxo normalmente segue a seguinte sequência:

Compilação
      ↓
Execução dos Testes DUnitX
      ↓
Delphi Code Coverage
      ↓
Geração do XML
      ↓
SonarQube Scanner
      ↓
Publicação dos Resultados

Essa abordagem permite que cada commit enviado ao repositório produza automaticamente métricas atualizadas de cobertura, tornando possível acompanhar a evolução da qualidade do projeto ao longo do tempo.

Uma prática bastante recomendada é armazenar os scripts de execução juntamente com o código-fonte da aplicação. Dessa forma toda a equipe utiliza exatamente a mesma configuração, evitando diferenças entre ambientes locais e servidores de build.

À medida que a maturidade da equipe aumenta, a execução pela linha de comando normalmente passa a ser o mecanismo principal de geração da cobertura, enquanto o Wizard permanece como uma ferramenta de apoio para configuração inicial e análise local dos resultados.

Boas Práticas

Ao implementar cobertura de código em Delphi, algumas recomendações costumam produzir melhores resultados.

• Priorize regras de negócio em vez de componentes visuais.
• Evite perseguir 100% de cobertura apenas por questões numéricas.
• Mantenha os testes simples e fáceis de entender.
• Integre a cobertura ao processo de build automatizado.
• Utilize o SonarQube para acompanhar a evolução dos indicadores ao longo do tempo.
• E principalmente, lembre-se de que cobertura é uma ferramenta para apoiar a qualidade, não um objetivo isolado.

Conclusão

Code Coverage é uma das métricas mais úteis para equipes que desejam evoluir a qualidade de seus projetos Delphi. Ela fornece uma visão objetiva sobre quais partes do sistema estão protegidas por testes automatizados e ajuda a direcionar os esforços de validação para as áreas que realmente importam.

Quando combinada com DUnitX, Delphi Code Coverage, Delphi Code Coverage Wizard Plus e SonarQube, a cobertura deixa de ser apenas um número e passa a fazer parte de uma estratégia mais ampla de qualidade de software.

Em um cenário onde sistemas Delphi continuam sustentando operações críticas em empresas de todos os portes, investir em testes automatizados e cobertura de código é uma das melhores formas de garantir segurança, previsibilidade e evolução sustentável do software.

Referências

EMBARCADERO TECHNOLOGIES. Delphi Code Coverage Wizard Plus. Disponível em: https://getitnow.embarcadero.com/delphi-code-coverage-wizard-plus/. Acesso em: 21 jun. 2026.

DELPHI CODE COVERAGE. Delphi Code Coverage. GitHub. Disponível em: https://github.com/DelphiCodeCoverage/DelphiCodeCoverage. Acesso em: 21 jun. 2026.

DUNITX PROJECT. DUnitX. Disponível em: https://github.com/VSoftTechnologies/DUnitX. Acesso em: 21 jun. 2026.