Introdução aos testes, depuração e tratamento de exceções
- 7 minutos
Todo desenvolvedor de software precisa concluir algum nível de teste e depuração quando desenvolve seu código, e o tratamento de exceções é frequentemente necessário. Mas como se relacionam estas três tarefas e quando devem ser implementadas?
Testes, depuração e tratamento de exceções
A depuração de código está claramente relacionada com o desenvolvimento e teste de código. Afinal, você faz correções na lógica do código à medida que desenvolve o aplicativo e também executa o código periodicamente para verificar se a sintaxe e a lógica do código estão corretas. Mas será que atualizar a lógica de código durante o processo de desenvolvimento é mesmo isso que se deve interpretar como depuração? E verificar se o seu código é compilado e executado é isso realmente o que se entende por testar? Não, não realmente.
Como o tratamento de exceções se relaciona com o desenvolvimento e teste de código? Na verdade, o que significa "tratamento de exceções" e espera-se que um desenvolvedor faça isso? No desenvolvimento em C#, os erros que ocorrem durante o tempo de execução do aplicativo (versus erros de compilação que ocorrem durante o processo de compilação) são chamados de exceções, e "tratamento de exceções" é o processo que um desenvolvedor usa para gerenciar essas exceções de tempo de execução em seu código.
Você pode estar se perguntando como o tratamento de exceções se relaciona com o desenvolvimento e teste de código. Na verdade, o que significa "tratamento de exceções" e espera-se que um desenvolvedor faça isso? No desenvolvimento em C#, os erros que ocorrem enquanto o aplicativo está em execução são chamados de exceções. O termo "tratamento de exceções" refere-se ao processo que um desenvolvedor usa para gerenciar essas exceções de tempo de execução em seu código. Os erros que ocorrem durante o processo de compilação são chamados de erros e não fazem parte do processo de tratamento de exceções.
As seções a seguir descrevem a função do desenvolvedor em testes, depuração e tratamento de exceções.
Responsabilidades de desenvolvimento e teste de software
O processo de desenvolvimento de software pode envolver muitos testes. Na verdade, o teste de software tem sua própria disciplina especializada, e os testadores de software desempenham um papel importante no desenvolvimento de grandes aplicações. Existem até abordagens para o processo de desenvolvimento de software que são baseadas em testes, como o desenvolvimento orientado a testes.
As categorias de teste de software podem ser organizadas sob os tipos de teste, as abordagens de teste ou uma combinação de ambos. Uma maneira de categorizar os tipos de teste é dividir os testes em testes funcionais e não funcionais . As categorias funcionais e não funcionais incluem subcategorias de testes. Por exemplo, os testes funcionais e não funcionais podem ser divididos nas seguintes subcategorias:
- Testes funcionais - Testes unitários - Testes de integração - Testes de sistema - Testes de aceitação
- Testes não funcionais - Testes de segurança - Testes de desempenho - Testes de usabilidade - Testes de compatibilidade
Embora a maioria dos desenvolvedores provavelmente não se considere testadores, algum nível de teste é esperado antes que um desenvolvedor entregue seu trabalho. Quando os desenvolvedores recebem uma função formal no processo de teste, geralmente é no nível do teste de unidade.
Observação
Como o teste de software é um tópico tão grande, e como geralmente é realizado por uma função de trabalho separada, as abordagens formais para o teste de software não serão discutidas neste módulo.
Depuração de código e responsabilidades do desenvolvedor
A depuração de código é um processo que os desenvolvedores usam para isolar um problema e identificar uma ou mais maneiras de corrigi-lo. O problema pode estar relacionado à lógica do código ou a uma exceção. De qualquer forma, você trabalha na depuração do seu código quando ele não está funcionando da maneira desejada. Em geral, o termo depuração é reservado para questões de execução que não são fáceis de isolar. Portanto, corrigir problemas de sintaxe, como um ";" ausente no final de uma instrução de código, normalmente não é considerado depuração.
Considere o seguinte código de exemplo:
string[] students = new string[] {"Sophia", "Nicolas", "Zahirah", "Jeong"};
int studentCount = students.Length;
Console.WriteLine("The final name is: " + students[studentCount]);
O exemplo de código destina-se a realizar o seguinte:
- Declare uma matriz de cadeia de caracteres chamada
students. Astudentsmatriz contém os nomes dos alunos. - Declare um inteiro chamado
studentCount. O código usa oLengthmétodo da matriz para atribuir um valor astudentCount. - Imprima o nome do aluno final no console. O código usa
studentCountpara acessar o nome final nastudentsmatriz e usa oConsole.WriteLine()método para imprimir as informações no console.
À primeira vista, tudo parece bem. No entanto, esse código gera uma exceção ao tentar imprimir o nome do aluno no console. O desenvolvedor esqueceu que os arrays são baseados em zero. O nome final na matriz deve ser acessado usando students[studentCount - 1].
A depuração de código é definitivamente uma responsabilidade do programador. Neste exemplo de código, você pode ter reconhecido o problema imediatamente. No entanto, em cenários de codificação mais complexos, encontrar um problema nem sempre é fácil. Não se preocupe, existem ferramentas e abordagens que você pode usar para rastrear problemas difíceis de encontrar.
Tratamento de exceções e responsabilidades do desenvolvedor
Como você leu anteriormente, os erros que ocorrem durante o tempo de execução do aplicativo são chamados de exceções. Se um aplicativo gerar uma exceção e essa exceção não for gerenciada no código, isso poderá resultar no encerramento do aplicativo.
Lidar com exceções é definitivamente uma responsabilidade do desenvolvedor. O C# fornece uma maneira de você "tentar" o código que você sabe que pode gerar uma exceção e uma maneira de "capturar" quaisquer exceções que ocorram.
Recapitulação
Aqui estão algumas coisas importantes para lembrar desta unidade:
- Testes, depuração e tratamento de exceções são tarefas importantes para desenvolvedores de software.
- Os testes podem ser categorizados em testes funcionais e não funcionais, e espera-se que os desenvolvedores realizem algum nível de teste.
- A depuração de código é o processo de isolar problemas e identificar maneiras de corrigi-los, e é uma responsabilidade do desenvolvedor.
- O tratamento de exceções é o processo de gerenciamento de erros que ocorrem durante o tempo de execução, e os desenvolvedores são responsáveis por lidar com exceções usando instruções "try" e "catch" em seu código.