GabaritoE — Errado
Gabarito: ERRADO. O debugging (depuração) não se limita a corrigir erros de sintaxe; ele é o processo de localizar e corrigir defeitos de qualquer natureza, incluindo erros lógicos, de execução e de integração. Além disso, os erros lógicos não são tratados exclusivamente por testes unitários — eles podem ser identificados e corrigidos em todos os níveis de teste (integração, sistema, aceitação) e também durante o próprio debugging. A afirmação restringe indevidamente o escopo do debugging e atribui aos testes unitários uma exclusividade que eles não têm.
O debugging é uma atividade que ocorre após a detecção de um defeito (falha) e envolve três etapas principais: (1) localizar a causa do defeito, (2) corrigir o código e (3) verificar se a correção resolveu o problema sem introduzir novos defeitos. Ele não se restringe a erros de sintaxe — na verdade, erros de sintaxe são os mais fáceis de detectar (geralmente o compilador ou interpretador os aponta), enquanto erros lógicos exigem análise cuidadosa do comportamento do programa, uso de ferramentas de depuração (breakpoints, inspeção de variáveis, execução passo a passo) e raciocínio sobre o fluxo de dados e controle.
Os testes unitários, por sua vez, são uma técnica de verificação que foca nas menores unidades de código (funções, métodos, classes) para garantir que cada uma se comporte conforme o esperado. Eles são uma ferramenta importante para detectar erros lógicos, mas não são o único mecanismo de tratamento: erros lógicos podem ser encontrados em testes de integração (quando módulos interagem), em testes de sistema (quando o software completo é exercitado), em testes de aceitação (quando o cliente valida o produto) e também durante a execução do debugging em si. Além disso, o debugging é uma atividade que complementa os testes — enquanto o teste revela a presença de um defeito, o debugging é o processo de encontrar e corrigir a causa raiz.
A banca explora aqui uma confusão conceitual clássica: restringir o debugging a erros de sintaxe e atribuir aos testes unitários o monopólio do tratamento de erros lógicos. Na prática, o debugging é uma atividade transversal que lida com qualquer tipo de defeito, e os testes unitários são apenas uma das muitas estratégias de detecção de defeitos — não a única, e não a que "trata" erros lógicos de forma exclusiva. O que os testes unitários fazem é verificar o comportamento de unidades isoladas; o que o debugging faz é corrigir o código, seja qual for a natureza do erro.
A banca tenta fazer você acreditar que o debugging é uma atividade restrita a erros de sintaxe e que os testes unitários são os únicos responsáveis por erros lógicos. Na verdade, o debugging lida com qualquer tipo de defeito (sintaxe, lógica, execução, integração), e os testes unitários são apenas uma das ferramentas de detecção — erros lógicos também são tratados em testes de integração, sistema, aceitação e durante o próprio debugging. Guarde isso: debugging = corrigir; teste = verificar. São atividades complementares, não excludentes.
A afirmação está incorreta por dois motivos: (1) o debugging não se restringe a erros de sintaxe — ele abrange a localização e correção de qualquer defeito, incluindo erros lógicos, de execução e de integração; (2) os erros lógicos não são tratados exclusivamente por testes unitários — eles podem ser detectados e corrigidos em todos os níveis de teste (integração, sistema, aceitação) e também durante o próprio processo de debugging. O debugging é uma atividade de correção que complementa os testes, que são atividades de verificação — ambos trabalham juntos para garantir a qualidade do software, mas com papéis distintos e não excludentes.
Gabarito: ERRADO.
Link permanente: /questoes/qg594704