Testes de Software e Validação

Os testes de software exigem prática ativa porque os alunos aprendem a antecipar erros ao lidarem diretamente com código real. Esta abordagem transforma conceitos abstratos em competências concretas, especialmente quando trabalham em equipa e testam casos inesperados.

• 10° Ano
• Pensamento Computacional e Literacia Digital Avançada
• 4 atividades
• 20 min–45 min

Objetivos de Aprendizagem

1. Analisar o impacto de diferentes tipos de entrada (válidas, inválidas, limites) no comportamento de um programa.
2. Comparar a eficácia de testes unitários e testes de integração na identificação de defeitos de software.
3. Criar casos de teste para cenários específicos, incluindo casos de limite (edge cases).
4. Justificar a importância da validação e testes contínuos no ciclo de vida do desenvolvimento de software.

Círculo de Investigação

⏱ 30 min·Pares

Par Programação: Testes Unitários

Os alunos trabalham em pares para escrever funções simples e criar testes unitários que cubram casos normais e edge cases. Executam os testes no interpretador e ajustam o código com base nos resultados falhados. Registam os testes num relatório partilhado.

Preparação e detalhes

Preveja comportamentos inesperados num programa com base em diferentes entradas.

Sugestão de Facilitação: Durante a par programação em testes unitários, circule pela sala para garantir que ambos os elementos do par discutem casos de teste antes de os implementarem.

Setup: Grupos em mesas com acesso a materiais de consulta

Materials: Coleção de fontes documentais, Ficha de trabalho do ciclo de investigação, Protocolo de formulação de perguntas, Modelo de apresentação de resultados

• Analisar
• Avaliar
• Criar
• Autogestão
• Autoconsciência

Círculo de Investigação

⏱ 45 min·Pequenos grupos

Rotação de Grupos: Testes de Integração

Divida a turma em grupos que desenvolvem módulos separados de um programa. Cada grupo testa a integração com módulos de outros grupos, identificando falhas de interface. Discutem soluções em plenário.

Preparação e detalhes

Compare diferentes tipos de testes (unitários, de integração) para garantir a robustez do software.

Sugestão de Facilitação: Na rotação de grupos de testes de integração, atribua componentes com dependências claras para que os alunos experienciem falhas reais em interações entre módulos.

Setup: Grupos em mesas com acesso a materiais de consulta

Materials: Coleção de fontes documentais, Ficha de trabalho do ciclo de investigação, Protocolo de formulação de perguntas, Modelo de apresentação de resultados

• Analisar
• Avaliar
• Criar
• Autogestão
• Autoconsciência

Círculo de Investigação

⏱ 20 min·Individual

Desafio Individual: Previsão de Erros

Forneça código com bugs ocultos. Os alunos preveem falhas para entradas específicas e escrevem testes preditivos antes de executar. Compar partilham previsões e resultados reais.

Preparação e detalhes

Justifique a importância de testar o código antes da sua implementação final.

Sugestão de Facilitação: No desafio individual de previsão de erros, forneça cartões com entradas específicas (vazias, limites, inválidas) para que os alunos simulem cenários sem pistas óbvias.

Setup: Grupos em mesas com acesso a materiais de consulta

Materials: Coleção de fontes documentais, Ficha de trabalho do ciclo de investigação, Protocolo de formulação de perguntas, Modelo de apresentação de resultados

• Analisar
• Avaliar
• Criar
• Autogestão
• Autoconsciência

Círculo de Investigação

⏱ 35 min·Turma inteira

Simulação em Aula: Debugging Colaborativo

Apresente um programa com erros. A turma divide-se em equipas para propor testes e validar correções. Votam na melhor estratégia e implementam coletivamente.

Preparação e detalhes

Preveja comportamentos inesperados num programa com base em diferentes entradas.

Sugestão de Facilitação: Na simulação de debugging colaborativo, interrompa a atividade em pontos-chave para pedir aos alunos que explicitem os erros que detetaram e como os resolveriam.

Setup: Grupos em mesas com acesso a materiais de consulta

Materials: Coleção de fontes documentais, Ficha de trabalho do ciclo de investigação, Protocolo de formulação de perguntas, Modelo de apresentação de resultados

• Analisar
• Avaliar
• Criar
• Autogestão
• Autoconsciência

Ensinar Este Tópico

Comece com exemplos visuais de bugs em sistemas conhecidos (como apps que falham com inputs longos) para mostrar a relevância dos testes. Evite explicar apenas teoria: use atividades que forcem os alunos a falhar e corrigir em tempo real. Pesquisas mostram que a aprendizagem é mais profunda quando os erros são parte integrante do processo, não apenas consequências a evitar.

O Que Esperar

Os alunos demonstram compreensão ao identificar casos limite, justificar testes unitários versus de integração e corrigir falhas em tempo real. A turma mostra progresso quando as discussões revelam consciência da importância dos testes desde as fases iniciais do desenvolvimento.

Atenção a estes erros comuns

Erro comum

Durante a atividade de Par Programação: Testes Unitários, alguns alunos podem dizer que os testes só servem para validar código funcional.

O que ensinar em alternativa

Peça aos pares que criem casos de teste com entradas inválidas ou limites (ex. lista vazia, valores negativos) antes de testarem o código funcional, mostrando que os testes previnem falhas ocultas.

Erro comum

Durante a Rotação de Grupos: Testes de Integração, os alunos confundem testes unitários com testes de integração.

O que ensinar em alternativa

Dê a cada grupo dois componentes com uma dependência clara (ex. função de cálculo + função de formatação) e peça-lhes para escreverem testes que falham quando a integração está incorreta, contrastando com testes unitários de cada função.

Erro comum

Durante o Desafio Individual: Previsão de Erros, os alunos consideram que entradas válidas são suficientes para garantir robustez.

O que ensinar em alternativa

Forneça um conjunto de entradas não óbvias (ex. strings com caracteres especiais, valores nulos) e peça-lhes para preverem falhas antes de executarem o código, discutindo os resultados em seguida.

Ideias de Avaliação

Verificação Rápida

Durante a atividade Par Programação: Testes Unitários, recolha os casos de teste criados por cada par e avalie se incluem entradas normais, limites e inválidas, com previsões de resultados esperados.

Questão para Discussão

Após a Rotação de Grupos: Testes de Integração, peça a cada grupo que partilhe os casos de teste que identificaram como críticos para a integração dos seus componentes, avaliando a justificação das escolhas.

Bilhete de Saída

No final da aula, entregue um cartão para cada aluno escrever: 1) A diferença principal entre teste unitário e de integração usando exemplos da atividade de Rotação de Grupos. 2) Um edge case para uma função que calcula a área de um círculo, baseando-se no Desafio Individual.

Extensões e Apoio

• Peça aos alunos que criem uma função com 5 casos de teste, incluindo dois edge cases não óbvios, e partilhem os resultados no final da aula.
• Para alunos com dificuldades, forneça templates de código com espaços para preencher casos de teste, destacando entradas críticas.
• Proponha um desafio de debugging em pares: um aluno escreve um bug intencional num código simples, o outro deve identificá-lo e corrigi-lo com testes adequados.

Vocabulário-Chave

Teste Unitário	Um tipo de teste de software que verifica pequenas unidades de código, como funções ou métodos, isoladamente para garantir que funcionam corretamente.
Teste de Integração	Um tipo de teste que verifica a interação entre diferentes módulos ou componentes de um sistema para garantir que funcionam em conjunto como esperado.
Caso de Teste	Um conjunto de condições e variáveis iniciais, passos de execução e resultados esperados projetado para verificar se uma funcionalidade específica de um programa funciona corretamente.
Caso de Limite (Edge Case)	Uma entrada ou condição que está nos extremos de um intervalo válido ou numa situação incomum que pode causar falhas num programa se não for tratada adequadamente.
Validação	O processo de verificar se o software atende aos requisitos do utilizador e às especificações, garantindo que faz o que deveria fazer.