code coverage tutorial
Este tutorial abrangente explica o que é Cobertura de Código em Teste de Software, seus tipos, vantagens e desvantagens:
O objetivo final de qualquer empresa de desenvolvimento de software é desenvolver software de boa qualidade. Para atingir esse objetivo, o software deve ser exaustivamente testado.
O teste é, portanto, uma parte integrante do desenvolvimento de um aplicativo de software. Portanto, é essencial que o software desenvolvido seja revisado pelo desenvolvedor (o que é feito durante a fase de teste de unidade) e, em seguida, seja passado para a equipe de CQ para ser completamente testado para garantir que tenha o mínimo ou nenhum bug.
O software é testado por unidade antes de ser liberado para a equipe de teste real para teste. Como esse teste envolve teste no nível do código, ele é feito pelo desenvolvedor. Isso é feito para garantir que cada parte do código testado funcione conforme o esperado.
Aqui, pequenos pedaços de código que foram desenvolvidos são testados isoladamente para garantir sua correção. Mas, a questão que muitas vezes surge na mente de um desenvolvedor é quanto de teste de unidade deve ser feito e a resposta para isso está na Cobertura do Código.
Este tutorial fornecerá a você um conhecimento profundo do que é a cobertura de código e por que precisamos dela. Você saberia como ele difere da Cobertura de Teste.
Devemos também dar uma olhada nas ferramentas e metodologias que são usadas para a cobertura de código e, no final deste tutorial, veremos os benefícios e as desvantagens. Alguns dos mitos associados à cobertura de código também seriam abordados aqui.
O que você aprenderá:
O que é cobertura de código
Esta é uma importante métrica de teste de unidade. É útil saber a eficácia dos testes de unidade. É uma medida que indica qual porcentagem do código-fonte seria executada durante o teste.
Em termos simples, a extensão em que o código-fonte de um programa de software ou aplicativo será executado durante o teste é o que é denominado de Cobertura de Código.
Se os testes executam toda a parte do código, incluindo todas as ramificações, condições ou loops, diríamos que há uma cobertura completa de todos os cenários possíveis e, portanto, a cobertura do código é 100%. Para entender isso ainda melhor, vamos dar um exemplo.
A seguir está um código simples que é usado para adicionar dois números e exibir o resultado dependendo do valor do resultado.
Input a, b Let c = a + b If c <10, print c Else, print ‘Sorry’
O programa acima tem duas entradas, ou seja, ‘a’ e ‘b’. A soma de ambos é armazenada na variável c. Se o valor de c for menor que 10, o valor de 'c' será impresso, caso contrário, 'Desculpe' será impresso.
Agora, se tivermos alguns testes para validar o programa acima com os valores de a & b de forma que a soma seja sempre menor que 10, então a outra parte do código nunca será executada. Em tal cenário, diríamos que a cobertura não é completa.
Este foi apenas um pequeno exemplo para esclarecer o significado da Cobertura do Código. À medida que explorarmos mais, você obterá melhor clareza sobre isso.
Por que precisamos de cobertura de código
[imagem fonte ]
Vários motivos tornam a cobertura de código essencial e alguns deles estão listados abaixo:
analista de negócios seguros perguntas da entrevista de domínio
- Isso ajuda a verificar se o software tem menos bugs quando comparado ao software que não tem uma boa cobertura de código.
- Ao ajudar a melhorar a qualidade do código, indiretamente ajuda a entregar um software de melhor 'qualidade'.
- É uma medida que pode ser usada para saber a eficácia do teste (eficácia dos testes de unidade que são escritos para testar o código).
- Ajuda a identificar as partes do código-fonte que não foram testadas.
- Isso ajuda a determinar se o teste atual (teste de unidade) é suficiente ou não e se mais alguns testes também são necessários.
Cobertura de código x cobertura de teste
Para entender a diferença entre a cobertura de código e a cobertura de teste, vamos primeiro entender o significado da cobertura de teste.
Cobertura de teste
É uma medida de quantas partes do teste esperado foram cobertas durante o teste de um software. De ‘Teste esperado’ queremos dizer o conjunto completo de casos de teste que são escritos para serem executados para testar um determinado software.
Suponha que, para testar um software, um conjunto de 500 casos de teste no total tenha sido escrito. Agora, como parte da atividade de teste, apenas 300 casos de teste foram executados. Vamos supor que isso seja devido à falta de tempo. Nesse caso, abaixo seria a cobertura do teste.
Cobertura de teste = (casos de teste executados / total de casos de teste) * 100
= (300/500) * 100
= 60%
Vamos comparar isso com o que é a cobertura de código.
Cobertura de código
É uma medida que mostra até que ponto o código-fonte de um aplicativo é executado durante o teste do código. Assim, mostra o grau em que um código-fonte seria testado.
Suponha que para testar um aplicativo com 500 linhas de código, apenas 400 linhas do código são executadas por testes. Vamos supor que isso seja devido a um determinado loop / condição não ser executado. Nesse caso, o seguinte seria a cobertura do código.
Cobertura de código = (número de linhas de código executadas / número total de linhas de código) * 100
= (400/500) * 100
= 80%
resto perguntas e respostas da entrevista para experientes
A seguir estão listadas as diferenças entre a cobertura de código e a cobertura de teste:
Cobertura de teste | Cobertura de código |
---|---|
É uma medida de quanta parte do teste esperado foi coberta durante o teste de um software. | É uma medida que mostra até que ponto o código-fonte de um aplicativo é executado durante o teste do código. |
A cobertura do teste pode ser calculada usando a fórmula abaixo: Cobertura de teste = (casos de teste executados / total de casos de teste) * 100 | A cobertura do código pode ser calculada usando a fórmula abaixo: Cobertura de código = (número de linhas de código executadas / número total de linhas de código) * 100 |
Metodologias
Aqui, discutiremos os vários métodos que são / podem ser usados para medir a cobertura do código.
Para entender essas metodologias, vamos dar uma olhada no snippet de código abaixo:
Add (int a, int b) { If (b > a) { b = b - a Print b } If (a > b) { b = a – b Print b } Else Print ‘0’ }
Cobertura de Declaração
Esta metodologia é uma medida que informa se todas as instruções executáveis possíveis do código no código-fonte foram executadas pelo menos uma vez. É um método para garantir que cada linha do código-fonte seja coberta pelo menos uma vez pelos testes.
Isso pode parecer simples, mas é preciso ter cuidado ao medir a cobertura da declaração. O motivo é que, em um código-fonte, pode haver uma determinada condição que pode não ser executada dependendo dos valores de entrada.
Isso significaria que todas as linhas de código não seriam cobertas no teste. Assim, podemos ter que usar conjuntos de valores de entrada diferentes para cobrir todas essas condições no código-fonte.
Por exemplo, no código-fonte acima, se os valores de entrada forem considerados 2 e 3, a parte ‘Else’ do código não será executada. No entanto, se os valores de entrada forem do tipo 3 e 2, a parte ‘If’ do código não será executada.
Isso significa que com qualquer conjunto de valores de nossa cobertura de declaração não seria 100%. Nesse caso, podemos ter que executar os testes com todos os três [(2, 3), (3, 2), (0, 0)] conjunto de valores para garantir 100% de cobertura da instrução.
Cobertura de função
Como o nome sugere, essa metodologia mede até que ponto as funções presentes no código-fonte são cobertas durante o teste. Todas as funções que estão no código-fonte são testadas durante a execução do teste. Novamente, deve-se garantir que testamos essas funções para valores variados, para que a função seja testada completamente.
Em um código-fonte, pode haver várias funções e, dependendo dos valores de entrada usados, uma função pode ou não ser chamada. Portanto, o objetivo da Cobertura de Função é garantir que cada função seja solicitada.
Por exemplo, no código-fonte acima, se nossos testes chamam a função ‘Adicionar’ pelo menos uma vez, então chamaríamos isso como uma Cobertura de Função completa.
Cobertura de condição
Em um código-fonte onde quer que tenhamos uma condição, o resultado seria um valor booleano verdadeiro ou falso. A cobertura de condições visa estabelecer se os testes cobrem ambos os valores, ou seja, verdadeiro, falso.
No código-fonte, quando cada condição que ocorre é avaliada para estados verdadeiro e falso, a cobertura de condição para o código é considerada completa.
Por exemplo, no código acima, se os conjuntos de valores (2, 3) e (4, 2) forem usados, a cobertura de condição será 100%. Quando o conjunto de dados (2, 3) é usado, então (b> a) é avaliado como verdadeiro e (a> b) é avaliado como falso. Da mesma forma, quando o conjunto de dados (4, 2) é usado, então (b> a) é avaliado como falso e (a> b) é avaliado como verdadeiro.
Assim, ambas as condições têm ambos os valores, ou seja, verdadeiro e falso coberto. Portanto, a cobertura de condição seria de 100%.
Cobertura de filial
Esta metodologia visa garantir que todos os ramos que aparecem em cada estrutura condicional sejam executados no código-fonte. Por exemplo, no código acima, todas as declarações ‘If’ e qualquer declaração ‘Else’ que a acompanha devem ser cobertas pelo teste para uma cobertura de filial de 100%.
Por exemplo, no código acima, se os conjuntos de valores (2, 3), (4, 2), (1, 1) forem usados, a cobertura da filial será 100%. Quando o conjunto de dados (2, 3) é usado, então (b> a) e o primeiro ramo 'If' é executado. Da mesma forma, quando o conjunto de dados (4, 2) é usado, então (a> b) avalia como verdadeiro e o segundo ramo 'If' é executado.
Então, com o conjunto de dados (1, 1), o ramo ‘Else’ é avaliado como verdadeiro e executado. Assim, garantindo 100% de Cobertura da Agência.
Cobertura de filial x cobertura de condição
A cobertura de ramos é freqüentemente confundida com a cobertura de condições, entretanto, as duas são diferentes.
Vamos entender isso com um exemplo simples.
If (a >0) & (b >0) Then Print “Hello” Else Print “Bye”
Vamos escrever o conjunto de dados necessário para completar Cobertura de filial:
(1, 1) - Neste caso, 'a' e 'b' são verdadeiros, então a condição If é executada.
(1, 0) - Neste caso, 'a' é verdadeiro e 'b' seria falso, então a outra parte do código é executada.
Como sabemos, o objetivo da Cobertura de Branch é fazer com que cada branch seja executado pelo menos uma vez e esse objetivo seja alcançado.
Cobertura de condição:
(1, 0) - Neste caso, 'a' é verdadeiro e 'b' seria falso.
(0, 1) - Neste caso, 'a' é falso e 'b' seria verdadeiro.
O objetivo da Cobertura de Condições é obter verdadeiro e falso para cada condição executada e esse objetivo é alcançado aqui.
Você notou que a outra parte não é executada na cobertura de condição? É aqui que a cobertura de condição difere da cobertura de filial.
Ferramentas para cobertura de código
Para medir a Cobertura de Código de qualquer Software, existem várias ferramentas disponíveis no mercado.
A seguir estão listadas algumas das ferramentas para sua referência:
- Parasoft JTest
- Testwell CTC ++
- Cobertura
- JaCoCo
- CodeCover
- BullseyeCoverage
- EMMA
- OpenCover
- NCover
- Squish COCO
- CoverageMeter
- GCT
- TCAT C / C ++
- Gretel
- JCov
Leitura Recomendada => Ferramentas de cobertura de código
O link acima incluirá as seguintes informações sobre essas ferramentas:
- Características principais
- Tipo de licença
- URL oficial
- Prós e contras
- Última versão
Benefícios
Como visto acima, é uma métrica de teste muito útil pelos motivos abaixo:
- Ajuda a identificar as áreas em um código-fonte que permaneceriam não testadas / descobertas pelos testes.
- É útil para identificar código usado / morto, melhorando assim a qualidade do código.
- A eficácia dos testes de unidade pode ser conhecida com a ajuda do Code Coverage.
- Software com melhor qualidade pode ser entregue usando essas métricas.
Inconvenientes
- Tentar almejar uma cobertura de código de 100% às vezes causa uma falta de robustez dos testes, resultando na perda de captura de cenários propensos a defeitos.
- Ao contrário da percepção comum, não pode garantir se o software projetado atende a todos os requisitos.
Mitos Vs Fatos
Mito | Facto |
---|---|
Ter 100% de cobertura de código garante que o software não terá bugs. | Não, 100% de cobertura de código não pode garantir um software livre de bugs. Uma boa cobertura de código aliada a bons esforços da equipe de CQ pode garantir um software com o mínimo ou nenhum bug. |
Ter 100% de cobertura de código significa que o código escrito é perfeito. | Não, na verdade, se requisitos importantes não foram capturados pelo código em primeiro lugar, o código não pode ser denominado como perfeito, apesar da Cobertura do Código ser 100%. |
A Cobertura de Código mede a eficácia dos testes realizados em um produto de Software. | Não, a cobertura de código é apenas uma medida usada para testar a eficácia dos testes de unidade, ou seja, os testes executados apenas no código-fonte de um software. |
FAQ's
P # 1) O que é uma cobertura de código aceitável?
Responda: Alcançar 100% de cobertura de código não deve ser o objetivo durante o teste de unidade de código de software. Mas porque não? Para entender o motivo, talvez você precise mergulhar um pouco mais fundo para entender o significado subjacente.
Quando almejamos uma cobertura de 100%, então é mais comum que todo o foco no projeto dos testes seja feito para garantir que cada instrução, loop, ramificação ou condição seja testada. Assim, acabamos colocando muitos esforços que podem não valer a pena, considerando o tempo gasto.
Além disso, focar em uma cobertura alta também resulta na perda de cenários importantes que podem ter os defeitos, porque tudo o que pretendemos é garantir que cada linha de código seja testada.
Focar em uma alta cobertura de código nem sempre é tão importante e nem pode ser um número fixo para testar códigos diferentes. No entanto, em geral, uma cobertura de 75% - 80% deve ser um número ideal.
Ao testar nosso código, o foco principal deve ser garantir a cobertura de cenários críticos e provavelmente sujeitos a erros. Se isso não for feito, apesar de ter 100% de cobertura de código, nossos testes simplesmente não terão eficácia de teste.
Q # 2) Como posso verificar a cobertura do meu código?
Responda: Para testar a porcentagem de cobertura de código que você pode ter alcançado pelos testes projetados para testar o código, temos várias ferramentas no mercado. Dependendo da linguagem de programação que se está usando, temos várias ferramentas.
array de objetos no programa de exemplo java
Alguns deles estão listados abaixo:
- Java - Cobertura, JaCoCo
- Javascript - Blanket.js, Istambul
- Pitão - Coverage.py
- Rubi - SimpleCov
Usando essas ferramentas, podemos obter um relatório de cobertura completo de nossos testes que nos ajudam a saber qual parte do código seria executada e qual seria perdida por nossos testes.
Q # 3) A cobertura de código é uma boa métrica?
Responda: Em cenários da vida real, isso é útil até certo ponto e de algumas maneiras particulares.
Olhando primeiro para suas limitações, sabemos muito bem que ter uma cobertura de 100% não garante que o Código esteja livre de bugs, nem garante que todos os requisitos foram cobertos no código, ou seja, apesar de uma cobertura de 100% do código, estamos é muito provável que haja bugs no código, pois a cobertura não garante que todos os cenários tenham sido testados.
Além disso, se os requisitos foram ignorados durante a gravação do código, não há mapeamento de requisitos com o código que é tratado como parte da Cobertura do Código.
Dito isso, não podemos negar que, quando usamos a cobertura de código como métricas, isso nos dá uma ideia se cobrimos os requisitos básicos de teste de cada linha de nosso código. Essa porcentagem de cobertura nos dá uma ideia de quantas partes de nosso código estão sendo executadas com nossos testes de unidade.
Ficamos sabendo quanto de nosso código não seria executado. Isso, por sua vez, nos ajuda a decidir quanto mais testes de unidade são necessários e para quais partes do código.
Podemos, portanto, concluir que ter uma cobertura ruim nos dá uma ideia da ineficácia dos testes de unidade. Ao mesmo tempo, garantir uma cobertura de 100% não é uma garantia para um código sem defeitos. Portanto, é necessário ter uma abordagem equilibrada, onde não enfatizamos demais a importância de almejar uma alta porcentagem de cobertura de código.
Q # 4) Como posso melhorar minha cobertura de código?
Responda: O Relatório de cobertura de código fornecido por ferramentas de cobertura como JaCoCo, Istanbul etc. mostra as áreas que são cobertas pelos testes e também aquelas que não seriam testadas.
Conhecendo as partes não testadas do código, os testes podem ser escritos manualmente ou usando qualquer ferramenta de automação para cobrir as áreas que, de outra forma, não seriam testadas e, assim, aumentar a cobertura do código.
Uma coisa importante a notar aqui é que embora possamos escrever centenas de linhas de código para testar uma função no código, a cobertura pode ser muito menor. O motivo é que aprofundar-se demais para testar uma parte do enorme código não ajudará a aumentar a cobertura do código.
Portanto, se a meta é aumentar a cobertura, é preciso ter cuidado para cobrir todas as funções, condições e loops, em vez de mergulhar profundamente em uma única função e escrever testes extensos para essa única função.
Conclusão
Um produto de software de alta qualidade é o que é necessário no mundo acelerado da Internet de hoje.
Garantir um software de boa qualidade não é responsabilidade apenas de um Engenheiro de QA, mas também do desenvolvedor. A Cobertura de Código é, portanto, de grande utilidade quando se trata de entregar um produto de qualidade para a equipe de QA pelo (s) desenvolvedor (es).
Este tutorial explicou tudo sobre a cobertura de código e seus usos. Também aprofundamos a compreensão da diferença entre cobertura de código e cobertura de teste. Além disso, entendemos as metodologias utilizadas junto com uma variedade de ferramentas de cobertura de código.
Benefícios e desvantagens foram informados aqui. Por fim, descobrimos alguns dos mitos e perguntas frequentes associadas à cobertura de código
Leitura feliz!!
Leitura recomendada
- As 15 principais ferramentas de cobertura de código (para Java, JavaScript, C ++, C #, PHP)
- 15 melhores ferramentas JAVA para desenvolvimento, construção, criação de perfil, cobertura de código e revisão
- Tutorial de funções / métodos C # com exemplos de código
- Tutorial de tratamento de exceções C # com exemplos de código
- Tutorial do Tortoise SVN: revisões no repositório de código
- Tutorial de comprimento de array Java com exemplos de código
- Tutorial do AWS CodeBuild: Extraindo código do Maven Build
- Tutorial SVN: Gerenciamento de código-fonte usando Subversion