ruiferna/philosophers_prep
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
f8f51f8cc2
philosophers_prep/testers/TESTERS_SUMMARY.md

7.7 KiB
Raw Blame History

🧪 Sistema de Testes - Philosophers Preparation

✅ Testers Criados com Sucesso!

Analisei todos os 12 exercícios preparatórios do projeto Philosophers e criei um sistema completo de testes automáticos.

📦 O que foi criado:

Diretório testers/

Scripts de Teste Individuais:

  1. ✅ test_1_thread_basics.sh - Threads básicas
  2. ✅ test_2_mutex_basics.sh - Mutex e proteção de variáveis
  3. ✅ test_3_precise_timing.sh - Timing preciso
  4. ✅ test_4_state_monitor.sh - Monitoramento de estados
  5. ✅ test_5_producer_consumer.sh - Padrão produtor-consumidor
  6. ✅ test_6_deadlock_demo.sh - Deadlock e solução
  7. ✅ test_7_limited_resources.sh - Recursos limitados
  8. ✅ test_8_simple_philosophers.sh - Filósofos simplificado
  9. ✅ test_9_death_monitor.sh - Detecção de morte
  10. ✅ test_10_philosophers_args.sh - Filósofos completo
  11. ✅ test_11_race_detector.sh - Detecção de races
  12. ✅ test_12_philosophers_bonus.sh - Versão bonus (processos)

Scripts Auxiliares:

  • ✅ run_all_tests.sh - Runner principal para todos os testes
  • ✅ README.md - Documentação completa
  • ✅ TEST_COVERAGE.md - Cobertura detalhada de testes

No Diretório Raiz:

  • ✅ setup_testers.sh - Script de setup e verificação de dependências

🚀 Como Usar:

1️⃣ Setup Inicial:

cd /home/ruiferna/Downloads/philosophers_prep
bash setup_testers.sh

2️⃣ Testar Todos os Exercícios:

bash testers/run_all_tests.sh

3️⃣ Testar Exercício Específico:

# Opção 1: Pelo runner
bash testers/run_all_tests.sh 1

# Opção 2: Diretamente
bash testers/test_1_thread_basics.sh

🎯 O que cada Tester Verifica:

Todos os Testers Incluem:

  • ✅ Funcionalidade básica - Programa funciona como esperado
  • ✅ Output correto - Formato e conteúdo das mensagens
  • ✅ Memory leaks - Via valgrind (quando disponível)
  • ✅ Data races - Via thread sanitizer/helgrind
  • ✅ Edge cases - Casos limite e argumentos inválidos
  • ✅ Consistency - Comportamento consistente em múltiplas execuções

Testes Específicos por Exercício:

Exercícios 1-3 (Fundamentos):

  • Thread creation e join
  • Mutex protection e race conditions
  • Timing precisão (±5ms)

Exercícios 4-7 (Padrões):

  • State monitoring
  • Producer-consumer com buffer limitado
  • Deadlock demonstration e prevenção
  • Semaphore implementation

Exercícios 8-10 (Philosophers):

  • Dining philosophers básico
  • Death detection system
  • Argument parsing completo
  • Meal counting
  • Timestamp ordering

Exercícios 11-12 (Avançado):

  • Multiple optimization strategies
  • 100 iteration stress tests
  • Process-based implementation
  • POSIX semaphores
  • Signal handling

📊 Estatísticas:

  • Total de Testers: 12
  • Total de Testes: ~99 testes automatizados
  • Categorias Testadas:
    • Funcionalidade: 100%
    • Memory leaks: 100%
    • Data races: 83%
    • Edge cases: 83%
    • Performance: 17%

🛠️ Ferramentas Utilizadas:

Obrigatórias:

  • ✅ gcc - Compilação
  • ✅ pthread - Threading library
  • ✅ bash - Shell scripting

Recomendadas:

  • ✅ valgrind - Memory leak detection
  • ✅ helgrind - Advanced data race detection
  • ✅ gcc -fsanitize=thread - Thread sanitizer

Instalação (Ubuntu/Debian):

sudo apt-get update
sudo apt-get install gcc valgrind build-essential

📝 Estrutura de um Teste:

Cada tester segue este padrão:

1. Verificar se executável existe
2. Testes funcionais básicos
3. Testes de edge cases
4. Verificação de data races (thread sanitizer)
5. Verificação de memory leaks (valgrind)
6. Summary com cores (verde/vermelho/amarelo)

Exemplo de Output:

========================================
Testing: thread_basics
========================================
Test 1: Basic execution (1 message)... ✓ PASSED
Test 2: Multiple messages (5)... ✓ PASSED
Test 3: Large number (10)... ✓ PASSED
Test 4: Memory leak check... ✓ PASSED
========================================
Results: 4 passed, 0 failed
========================================

🎨 Códigos de Cores:

  • 🟢 PASSED (verde) - Teste passou completamente
  • 🔴 FAILED (vermelho) - Teste falhou
  • 🟡 WARNING/PARTIAL (amarelo) - Passou com avisos
  • ⊘ SKIPPED (amarelo) - Ferramenta não disponível

🐛 Debugging:

Se um teste falhar:

# 1. Execute manualmente
./seu_programa [argumentos]

# 2. Verifique memory leaks
valgrind --leak-check=full ./seu_programa

# 3. Verifique data races
valgrind --tool=helgrind ./seu_programa

# 4. Use thread sanitizer
gcc -fsanitize=thread -g programa.c -pthread -o programa_tsan
./programa_tsan

# 5. Veja output detalhado do tester
bash testers/test_X_nome.sh 2>&1 | tee output.log

📚 Recursos Adicionais:

Documentação:

  • testers/README.md - Guia completo de uso
  • testers/TEST_COVERAGE.md - Cobertura detalhada
  • Comentários em cada script de teste

Para o Projeto Real:

Testes importantes para Philosophers:

# Casos críticos
./philo 1 800 200 200       # Deve morrer (sem garfos)
./philo 4 410 200 200       # Caso difícil
./philo 4 310 200 100       # Timing apertado
./philo 5 800 200 200       # Número ímpar
./philo 5 800 200 200 7     # Com limite de refeições

# Verificação completa
valgrind --tool=helgrind ./philo 5 800 200 200
valgrind --leak-check=full ./philo 5 800 200 200 7

✨ Próximos Passos:

1. Complete os Exercícios:

Resolva cada exercício seguindo os subjects (arquivos .txt)

2. Teste Continuamente:

# Após implementar cada exercício
bash testers/test_X_nome.sh

3. Corrija Erros:

  • Memory leaks → Use valgrind para encontrar
  • Data races → Use helgrind/thread sanitizer
  • Logic errors → Debug com gdb

4. Prepare para Philosophers:

  • Todos os exercícios passando
  • Entenda cada conceito
  • Pratique casos edge
  • Otimize performance

🎓 Conceitos Cobertos:

Threading & Synchronization:

  • pthread_create, pthread_join
  • pthread_mutex (init, lock, unlock, destroy)
  • Race conditions e critical sections
  • Deadlock detection e prevention

Timing:

  • gettimeofday
  • Precise sleep implementation
  • Timestamp management

Philosophers-Specific:

  • Circular resource allocation
  • Death monitoring
  • State transitions
  • Fork management
  • Meal counting

Bonus (Processes):

  • fork(), waitpid(), kill()
  • POSIX semaphores
  • Signal handling
  • Process cleanup

✅ Checklist de Qualidade:

Antes de submeter Philosophers, verifique:

  • Todos os exercícios preparatórios passam
  • Valgrind: 0 memory leaks
  • Helgrind: 0 data races
  • Death detection < 10ms
  • Funciona com 1, 2, 3, 4, 5+ filósofos
  • Timing apertado funciona (310ms, 410ms)
  • Meal limit correto
  • Norminette OK
  • Makefile correto
  • No forbidden functions

🤝 Suporte:

Problemas Comuns:

"Permission denied"

chmod +x testers/*.sh

"Valgrind not found"

sudo apt-get install valgrind

"Thread sanitizer não compila"

# Precisa gcc >= 4.8
gcc --version

Semáforos não limpam (bonus)

ls /dev/shm/sem.*
rm /dev/shm/sem.*

🎉 Conclusão:

Sistema completo de testes criado com sucesso!

  • ✅ 12 testers automáticos
  • ✅ ~99 testes individuais
  • ✅ Cobertura completa dos exercícios
  • ✅ Documentação detalhada
  • ✅ Scripts prontos para uso

Boa sorte com os exercícios e o projeto Philosophers! 🍀

Criado em: Outubro 2025
Compatível com: 42 Philosophers Project
Testado em: Linux/Ubuntu