Os testes unitários são fantásticos para descobrirmos os problemas de nosso código-fonte, porque suas rotinas exaurem as “unidades” em busca de problemas, certificando nosso código-fonte e nos dando a tranquilidade de seguirmos em frente, sabendo que o trabalho foi bem feito. Todavia, o que garante que testamos todos os pontos do sistema? Quanto maior o sistema, maior a probabilidade de esquecermos de algo, até porque, em grandes sistemas como ERPs, temos toneladas de classes e mais classes, funções e mais funções, que precisam ser devidamente analisadas.
Para nossa felicidade, existe algo que faz a análise da cobertura do código fonte. Entendendo melhor isso, faço a seguinte pergunta: e se houvesse algo que dissesse exatemente onde o seu código foi testado, e onde não foi? Parece genial, não é? Pois é exatamente isso que uma ferramenta de cobertura de código faz. Ela rastreia a execução do sistema e verifica cada linha do código-fonte que foi executada e nos retornar posteriormente uma análise demonstrando qual parte do sistema não foi executado. Isso, alinhado com um framework de testes unitários como o DUnitX, por exemplo, demonstra qual parte do seu sistema não foi testada. No Delphi, utilizamos para isso o Delphi Code Coverage.
Delphi Code Coverage
Site do Projeto: https://github.com/magicmonty/delphi-code-coverage
O Delphi Code Coverage é um programa bem simples. Ele utiliza as informações contidas no arquivo .map gerado pelo Delphi para identificar quais linhas do código-fonte a execução do programa percorreu.
Uma vez tudo configurado, a execução do Delphi Code Coverage gera um relatório com os percentuais entre os totais de linhas geral e aqueles que foram utilizados, além de identificar quais linhas não foram utilizadas. Assim, o desenvolvedor tem tudo o que precisa para aprimorar seus testes e fazer com que todas as linhas do código-fonte sejam testadas.
Configurações do Delphi
Como visto, é necessário que o arquivo .map do Delphi seja gerado para o correto funcionamento da ferramenta.
Para isso, vá em: Menu Project->Options->Delphi Compiler->Linking e altera a opção Map File para Detailed.

Configurando o Delphi Code Coverage
Dois arquivos são necessários para o funcionamento do Delphi Code Coverage:
- dcov_paths.lst – Informa quais os caminhos do código-fonte (paths).
- dcov_units.lst – Informa quais units, dentro do caminho informado em dcov_paths.lst, terão a cobertura de código.
Veja que isso é feito de propósito. Porque não apenas informar o caminho e considerar todas as units daquele caminho? Porque nem sempre todas as units deverão sofrer essa análise. O mesmo vale para informar em dcov_units.lst a unit do seu projeto. O Delphi Code Coverage é inteligente o suficiente para identificar as “units dentro das units”, declaradas nos “uses” do código-fonte, e realizar o rastreamento delas também. Assim, se você informar a unit do seu projeto, a ferramenta de cobertura de código vai atrás de todas as units informadas no projeto. Mas isso é interessante? Provavelmente não. Existem units que não devem passar pela análise porque dizem respeito à interfaces gráficas ou qualquer outra coisa que não envolva regras de negócio. Não estou dizendo que isso não precise ser testado, mas isso passa por outras etapas de testes. O que queremos aqui é verificar se as nossas regras de negócio estão sendo tratadas pelos testes unitários.
Veja exemplos dos conteúdos desses arquivos:
dcov_paths.lst
1 2 3 |
C:\Projetos\Fontes\Cadastros C:\Projetos\Fontes\Consultas ..\Fontes\Relatorios |
O conteúdo acima é bem simplista, apenas para compreender o correto funcionamento. Veja que é possível inclusive informar o caminho absoluto ou relativo, conforme sua necessidade.
dcov_units.lst
1 2 3 |
UCadastro UConsulta URelatorio |
Outra vez bem simples. Apenas o nome das units, sem qualquer extensão.
Pronto! Já podemos utilizá-lo. Mas e agora? Como faço isso?
Como o Delphi Code Coverage é um programa console, você deve utilizá-lo através do console do windows:
1 |
CodeCoverage.exe -e "C:\Projetos\Fontes\ProjetoTeste.exe" -m "C:\Projetos\Fontes\ProjetoTeste.map" -uf dcov_units.lst -spf dcov_paths.lst -od "C:\Projetos\Fontes\CodeCoverageOutput\Reports\" -lt -emma -meta -xml -html |
Vamos entender cada ponto:
- CodeCoverage.exe – É o comando para execução do CodeCoverage.
- -e “C:\Projetos\Fontes\ProjetoTeste.exe” – (e = Executable ou Executável)- Informa o caminho do executável do nosso projeto de teste.
- -m “C:\Projetos\Fontes\ProjetoTeste.map” – (m = map) – Informa o caminho do arquivo .map gerado pelo Delphi.
- -uf dcov_units.lst – (uf = unit file ou arquivo das units) – Caminho do arquivo dcov_units.lst, que é o arquivo que contém as units a serem analisadas.
- -spf dcov_paths.lst – (spf = source paths file ou arquivo dos caminnhos do fonte) – Caminho do arquivo dcov_paths.lst, que é o que contém os caminhos das units informadas em dcov_units.lst.
- -od “C:\Projetos\Fontes\CodeCoverageOutput\Reports\” – (od = output directory ou diretório de saída) – Caminho do diretório de saída do Delphi Code Coverage. É o caminho onde serão gerados os relatórios.
- -lt – (lt = logging text ou arquivo texto de log) – Informa o caminho do arquivo de log do programa. Se não for informado um caminho, será gerado o arquivo Delphi-Code-Coverage-Debug.log.
- -emma e -meta – Essa opção gera o arquivo coverage.es no formato Emma no diretório de saída. Esse arquivo pode ser utilizado junto ao programa Emma, que é um programa muito conhecido de cobertura de código para Java (Quer saber mais sobre Emma? Acesse: http://emma.sourceforge.net). A opção -meta informa que devem ser gerados arquivos separados para a cobertura e os metadados (arquivos coverage.em e coverage.ec). Não é necessário se não for utilizar Emma.
- -xml – Gera o relatório CodeCoverage_Summary.xml em formato XML no diretório de saída.
- -html – Gera o relatório CodeCoverage_Summary.html em formato HTML no diretório de saída.
Ainda é possível utilizar outras opções como:
- -dproj – Informa o caminho do projeto do Delphi.
- -u unit1 unit2 – Informa uma lista de units para a criação dos relatórios (informadas na própria linha de comando).
- -esm mask1 mask2 – Uma lista de arquivos para excluir da execução da cobertura do código.
- -uf filename – Informa uma lista de units para a criação dos relatórios (informadas em um arquivo, onde filename é o caminho do arquivo).
- -sd directory – (sd = source directory ou diretório dos fontes) – Informa o caminho do diretório dos fontes, onde “directory ” é o caminho.
- -a param param2 -Lista de parâmetros passada para a aplicação no momento da execução.
- -v – (v = verbose output ou saída detalhada) – Informa que deseja visualizar as saídas de forma detalhada.
- -lapi – Informa que deseja utilizar WinAPI OutputDebugString para o debug.
- -ife – Inclui prefixos de arquivos.
- -efe – Exclui prefixos de arquivos.
- -mns name dll [dll2] – Crie um namespace separado com o nome dado para as DLL listadas.
- -uns dll_or_exe unitname [unitname2] – Crie um namespace separado (o namespace será o nome do módulo sem extensão) – somente – para as unidades listadas dentro do módulo.
Algo legal que se fazer é criar seu próprio .bat para executar seu comando, facilitando as próximas execuções da cobertura do código.
Analisando o relatório
Agora que executamos a cobertura de código, foi gerado o arquivo CodeCoverage_Summary.html:

Ele mostra os percentuais entre o total de linhas da unit e aquelas que tiveram execução.

Veja que as linhas em verde são onde a execução do programa passou. As linhas em azul indicam que não foram executadas. Assim, fica claro que precisamos desenvolver para elas testes que as utilizem e analisem seus resultados.
Simples não é?
Delphi Code Coverage Wizard
Site do Projeto: https://github.com/trident-job/delphi-code-coverage-wizard
Desenvolvido para facilitar a configuração do Delphi Code Coverage, o Delphi Code Coverage Wizard gera os arquivos necessários para o funcionamento da cobertura de código. Assim você não precisa se preocupar com todas as configurações do Delphi Code Coverage, porque o Wizard irá lhe auxiliar quanto a isso. Todavia, saiba que conforme sua exeperiência e necessidades na utilização dessa ferramenta de cobertura de código forem crescendo, maior aa tendência para não utilizar o wizard, visto que suas necessidades irão se modificando e se aperfeiçoando no uso da ferramenta.
Na execução do wizard, temos depois da tela de boas vindas:





Perceba que o Wizzard faz exatamente o que fizemos antes. A vantagem dele é justamente facilitar a criação de todas as configurações necessárias.
Valo notar que o Wizzard possui seu próprio arquivo do Delphi Code Coverage.
Outras Informações
Quer saber mais sobre testes unitários? Click Aqui!
Quer saber mais sobre o arquivo .map? Click Aqui!
Quer tentar outras ferramentas de cobertura de código para Delphi? Qua tal tentar o Discover for Delphi? Click Aqui!