Marque a alternativa que apresenta apenas tipos de itens apresentados no relatório de cobertura da f...

Alternativa D - statements(comandos),missing(ausentes),excluded(excluídas),partial(parcial).

Introdução

A ferramenta Coverage.py é essencial no ecossistema Python para a análise de cobertura de código. Ela mede a porcentagem de código-fonte que é executada durante a execução de um conjunto de testes, ajudando os desenvolvedores a identificar áreas do código que não estão sendo testadas adequadamente. O relatório gerado por essa ferramenta apresenta diversas métricas e tipos de itens que são cruciais para entender a qualidade e a completude da suíte de testes.

Desenvolvimento

A cobertura de código é uma métrica fundamental no desenvolvimento de software de alta qualidade. Ela não apenas indica o quanto do seu código é testado, mas também indiretamente sugere a robustez da sua suíte de testes. O Coverage.py funciona instrumentando o código-fonte antes da execução, rastreando quais linhas são executadas. Após a execução dos testes, ele compila esses dados em um relatório detalhado.

Os principais conceitos envolvidos nos relatórios do Coverage.py incluem:

• Linhas executáveis (statements): Refere-se ao número total de linhas de código que a ferramenta considera como passíveis de execução e, portanto, de cobertura.
• Linhas ausentes (missing): São as linhas de código executável que não foram executadas pelos testes. O objetivo é minimizar esse número.
• Linhas parciais (partial): Isso geralmente se refere a linhas que contêm lógica de ramificação (como if, else, while, for) onde apenas algumas das ramificações possíveis foram executadas. Por exemplo, em um if/else, se apenas o bloco if foi executado, a linha é considerada "parcial" se o else também existia mas não foi atingido.
• Linhas excluídas (excluded): São linhas de código que o desenvolvedor explicitamente configurou para serem ignoradas pela análise de cobertura. Isso é útil para partes do código que não são testáveis (ex: chamadas de logger de baixo nível) ou que são geradas automaticamente.

Análise

A alternativa correta é a (D) porque ela lista precisamente os tipos de itens que são apresentados de forma proeminente e individual no relatório de cobertura gerado pelo Coverage.py.

Vamos analisar cada item e as alternativas:

| Termo em Português | Termo em Inglês (Coverage.py) | Descrição no Contexto do Coverage.py | Presença na Alternativa D | Status | | :----------------- | :----------------------------- | :----------------------------------- | :----------------------- | :----- | | comandos | statements | O total de linhas de código executáveis detectadas. | Sim | Correta | | ausentes | missing | As linhas de código que não foram executadas pelos testes. | Sim | Correta | | excluídas | excluded | As linhas de código que foram intencionalmente ignoradas na análise de cobertura. | Sim | Correta | | parcial | partial | Indica linhas com ramificações onde nem todas as ramificações foram executadas. | Sim | Correta |

Agora, vamos analisar as outras alternativas para entender por que estão incorretas:

• (A) statements(comandos),lacking(faltantes),included(incluídas),partial(parcial).

  • lacking não é um termo padrão. O termo correto é missing.
  • included não é um tipo de item listado; as linhas são contadas como statements, e sua execução é verificada para serem missing ou cobertas.

• (B) statements(comandos),missing(ausentes),included(incluídas),total(total).

  • included está incorreto, como explicado acima.
  • total é geralmente um resumo ou uma soma de outras categorias (ex: "Total Statements"), não um tipo de item fundamental como statements ou missing por si só.

• (C) statements(comandos),lacking(faltantes),excluded(excluídas),total(total).

  • lacking está incorreto (o correto é missing).
  • total está incorreto, como explicado acima.

• (E) statements(comandos),lacking(faltantes),included(incluídas),total(total).

  • lacking está incorreto.
  • included está incorreto.
  • total está incorreto.

A alternativa (D) contém todos os termos que o Coverage.py utiliza para classificar e reportar o estado de cobertura das linhas de código: statements (o universo de linhas a serem cobertas), missing (as que não foram atingidas), excluded (as que devem ser ignoradas) e partial (as que foram parcialmente atingidas em termos de ramificação).

Conclusão

Compreender os tipos de itens apresentados no relatório do Coverage.py é fundamental para interpretar corretamente os resultados da cobertura de código. Os termos statements, missing, excluded e partial representam as categorias essenciais que a ferramenta utiliza para detalhar a execução do código-fonte durante os testes, permitindo aos desenvolvedores uma visão clara das áreas bem testadas e daquelas que necessitam de mais atenção.

Alternativa D.