ruiferna/philosophers_prep
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
00a1df51bb
philosophers_prep/testers/TEST_COVERAGE.md

9.3 KiB
Raw Blame History

📊 Test Coverage Summary

VisĂŁo Geral dos Testers

Este documento resume a cobertura de testes para cada exercĂ­cio preparatĂłrio do Philosophers.

📝 Exercício 1: Thread Basics

Arquivo: test_1_thread_basics.sh

Testes Implementados:

  1. ✅ Execução básica com 1 mensagem
  2. ✅ MĂșltiplas mensagens (5)
  3. ✅ NĂșmero grande de mensagens (10)
  4. ✅ Verificação de memory leaks (valgrind)

O que Ă© verificado:

  • Thread 1 e Thread 2 criam mensagens corretas
  • NĂșmero correto de mensagens por thread
  • Threads fazem join corretamente

🔒 Exercício 2: Mutex Basics

Arquivo: test_2_mutex_basics.sh

Testes Implementados:

  1. ✅ Valor do contador (deve ser 4000)
  2. ✅ Teste de consistĂȘncia (5 execuçÔes)
  3. ✅ Tempo de execução reportado
  4. ✅ Detecção de data races (thread sanitizer)
  5. ✅ Memory leaks

O que Ă© verificado:

  • Mutex protege corretamente a variĂĄvel compartilhada
  • Resultado Ă© sempre 4000 (sem race conditions)
  • Thread sanitizer nĂŁo detecta problemas

⏱ ExercĂ­cio 3: Precise Timing

Arquivo: test_3_precise_timing.sh

Testes Implementados:

  1. ✅ Programa executa com sucesso
  2. ✅ PrecisĂŁo do sleep (~100ms ±5ms)
  3. ✅ ConsistĂȘncia atravĂ©s de 5 execuçÔes
  4. ✅ Formato do output
  5. ✅ Memory leaks

O que Ă© verificado:

  • Sleep preciso de 100ms
  • Margem de erro aceitĂĄvel (95-105ms)
  • FunçÔes de timing funcionam corretamente

📡 Exercício 4: State Monitor

Arquivo: test_4_state_monitor.sh

Testes Implementados:

  1. ✅ Execução do programa
  2. ✅ TransiçÔes de estado (WORKING, RESTING, THINKING)
  3. ✅ Timestamps presentes
  4. ✅ 3 workers identificados
  5. ✅ Duração de estados verificada
  6. ✅ Monitor thread funcionando
  7. ✅ Memory leaks
  8. ✅ Data races

O que Ă© verificado:

  • 3 workers + 1 monitor
  • Estados mudam corretamente
  • Monitor detecta workers travados

🏭 Exercício 5: Producer-Consumer

Arquivo: test_5_producer_consumer.sh

Testes Implementados:

  1. ✅ Programa completa execução
  2. ✅ Produtores funcionando
  3. ✅ Consumidores funcionando
  4. ✅ Items 1-100 produzidos
  5. ✅ Gestão de buffer
  6. ✅ Sem duplicação de consumo
  7. ✅ Data races
  8. ✅ Memory leaks

O que Ă© verificado:

  • 2 produtores + 2 consumidores
  • Buffer de 10 items funciona
  • Todos os 100 items sĂŁo processados
  • Sem race conditions

🔮 Exercício 6: Deadlock Demo

Arquivo: test_6_deadlock_demo.sh

Testes Implementados:

  1. ✅ Modo deadlock (deve travar)
  2. ✅ Modo solução (deve completar)
  3. ✅ Output da solução
  4. ✅ Ambas threads completam
  5. ✅ ConsistĂȘncia da solução (5 runs)
  6. ✅ Uso de mutex
  7. ✅ Handling de argumentos inválidos
  8. ✅ Memory leaks

O que Ă© verificado:

  • Deadlock Ă© demonstrado no modo 0
  • Solução funciona no modo 1
  • Ordem consistente de locks previne deadlock

🎯 Exercício 7: Limited Resources

Arquivo: test_7_limited_resources.sh

Testes Implementados:

  1. ✅ Programa completa
  2. ✅ 10 estudantes presentes
  3. ✅ Mensagens de chegada
  4. ✅ Obtenção de computadores
  5. ✅ Mensagens de saída
  6. ✅ Limite de 3 recursos simultñneos
  7. ✅ Fairness (nenhum starved)
  8. ✅ Data races
  9. ✅ Memory leaks

O que Ă© verificado:

  • SemĂĄforo implementado com mutex
  • MĂĄximo 3 usuĂĄrios simultĂąneos
  • Todos os 10 estudantes usam o recurso

đŸœïž ExercĂ­cio 8: Simple Philosophers

Arquivo: test_8_simple_philosophers.sh

Testes Implementados:

  1. ✅ Duração do programa (~10s)
  2. ✅ 3 filósofos presentes
  3. ✅ AçÔes de pensar
  4. ✅ AçÔes de comer
  5. ✅ Timestamps
  6. ✅ Todos os filósofos comem
  7. ✅ Sem mortes
  8. ✅ Data races
  9. ✅ Sem deadlock (3 runs)
  10. ✅ Memory leaks

O que Ă© verificado:

  • 3 filĂłsofos, 3 garfos
  • Ciclo thinking → eating funciona
  • Ordem de garfos previne deadlock
  • Programa roda ~10 segundos

☠ ExercĂ­cio 9: Death Monitor

Arquivo: test_9_death_monitor.sh

Testes Implementados:

  1. ✅ Execução do programa
  2. ✅ 4 workers presentes
  3. ✅ Atividade dos workers
  4. ✅ Monitor thread
  5. ✅ Detecção de morte
  6. ✅ Timestamps
  7. ✅ Tracking de last_activity
  8. ✅ Data races
  9. ✅ ConsistĂȘncia (3 runs)
  10. ✅ Memory leaks

O que Ă© verificado:

  • Monitor verifica a cada 100ms
  • Detecta "morte" apĂłs 3s de inatividade
  • Mutex protege last_activity_time

🎓 Exercício 10: Philosophers Args (Completo)

Arquivo: test_10_philosophers_args.sh

Testes Implementados:

  1. ✅ Caso básico (5 800 200 200) - sem mortes
  2. ✅ Cenário de morte (4 310 200 100)
  3. ✅ Limite de refeiçÔes (5 800 200 200 7)
  4. ✅ Filósofo sozinho (deve morrer)
  5. ✅ Argumentos inválidos
  6. ✅ IDs de filósofos válidos
  7. ✅ Timestamps crescentes
  8. ✅ Timing de detecção de morte
  9. ✅ Data races
  10. ✅ NĂșmero Ă­mpar de filĂłsofos
  11. ✅ Memory leaks

O que Ă© verificado:

  • Parsing completo de argumentos
  • Detecção de morte funciona
  • Limite de refeiçÔes funciona
  • Casos edge (1 philo, timing apertado)
  • Timestamps sĂŁo monotĂŽnicos

🔍 Exercício 11: Race Detector

Arquivo: test_11_race_detector.sh

Testes Implementados:

  1. ✅ Execução básica
  2. ✅ MĂșltiplas iteraçÔes
  3. ✅ Relatório de estatísticas
  4. ✅ Diferentes estratĂ©gias
  5. ✅ Helgrind check
  6. ✅ NĂșmero Ă­mpar de filĂłsofos
  7. ✅ Timing apertado
  8. ✅ MĂ©tricas de performance
  9. ✅ Thread sanitizer
  10. ✅ Memory leaks

O que Ă© verificado:

  • Testa 100 iteraçÔes
  • Compara estratĂ©gias A, B, C
  • Reporta races, deaths, performance
  • Helgrind/DRD detectam problemas

🌟 Exercício 12: Philosophers Bonus

Arquivo: test_12_philosophers_bonus.sh

Testes Implementados:

  1. ✅ Caso básico com processos
  2. ✅ Usa fork() (não threads)
  3. ✅ Usa semáforos POSIX
  4. ✅ Cenário de morte
  5. ✅ Limite de refeiçÔes
  6. ✅ Filósofo sozinho
  7. ✅ Argumentos inválidos
  8. ✅ Cleanup de processos (no zombies)
  9. ✅ Cleanup de semáforos
  10. ✅ Estatísticas finais
  11. ✅ Helgrind no processo pai

O que Ă© verificado:

  • Usa processos (fork) em vez de threads
  • SemĂĄforos POSIX (sem_open, sem_wait, sem_post)
  • Cleanup correto (sem_unlink)
  • Signal handling (SIGINT, SIGTERM)
  • Sem processos zombie

🎯 Estatísticas Gerais

Total de Testes:

  • ExercĂ­cio 1: 4 testes
  • ExercĂ­cio 2: 5 testes
  • ExercĂ­cio 3: 5 testes
  • ExercĂ­cio 4: 8 testes
  • ExercĂ­cio 5: 8 testes
  • ExercĂ­cio 6: 8 testes
  • ExercĂ­cio 7: 9 testes
  • ExercĂ­cio 8: 10 testes
  • ExercĂ­cio 9: 10 testes
  • ExercĂ­cio 10: 11 testes
  • ExercĂ­cio 11: 10 testes
  • ExercĂ­cio 12: 11 testes

TOTAL: ~99 testes automatizados

Categorias de Testes:

  • ✅ Funcionalidade bĂĄsica: 12/12 exercĂ­cios
  • ✅ Memory leaks (valgrind): 12/12 exercĂ­cios
  • ✅ Data races (sanitizer): 10/12 exercĂ­cios
  • ✅ Edge cases: 10/12 exercĂ­cios
  • ✅ ConsistĂȘncia: 8/12 exercĂ­cios
  • ✅ Performance: 2/12 exercĂ­cios

Ferramentas Utilizadas:

  • gcc - Compilação e thread sanitizer
  • valgrind - Memory leak detection
  • helgrind - Data race detection (avançado)
  • timeout - Detecção de deadlocks/hangs
  • grep/sed/awk - Parsing de output
  • ps - Verificação de processos zombie

🔑 Conceitos-Chave Testados

Threading:

  • pthread_create
  • pthread_join
  • pthread_detach
  • Thread arguments
  • Multiple threads

Synchronization:

  • pthread_mutex_init/destroy
  • pthread_mutex_lock/unlock
  • Critical sections
  • Race conditions
  • Deadlock prevention

Timing:

  • gettimeofday
  • Precise sleep
  • Timestamp generation
  • Time difference calculation

Processes (Bonus):

  • fork()
  • waitpid()
  • kill()
  • Signal handling
  • Process cleanup

Semaphores (Bonus):

  • sem_open
  • sem_wait/sem_post
  • sem_close/sem_unlink
  • Named semaphores

Philosophers-Specific:

  • Circular resource allocation
  • Death detection
  • Meal counting
  • State transitions
  • Monitor pattern
  • Fork ordering (deadlock prevention)

📈 Níveis de Dificuldade

Iniciante (ExercĂ­cios 1-3):

  • Thread Basics ⭐
  • Mutex Basics ⭐
  • Precise Timing ⭐⭐

IntermediĂĄrio (ExercĂ­cios 4-7):

  • State Monitor ⭐⭐
  • Producer-Consumer ⭐⭐⭐
  • Deadlock Demo ⭐⭐
  • Limited Resources ⭐⭐⭐

Avançado (Exercícios 8-10):

  • Simple Philosophers ⭐⭐⭐⭐
  • Death Monitor ⭐⭐⭐⭐
  • Philosophers Args ⭐⭐⭐⭐⭐

Expert (ExercĂ­cios 11-12):

  • Race Detector ⭐⭐⭐⭐⭐
  • Philosophers Bonus ⭐⭐⭐⭐⭐

✹ Próximos Passos

Depois de completar todos os exercĂ­cios:

  1. Revise conceitos:

    • Data races e como evitĂĄ-los
    • Deadlock e estratĂ©gias de prevenção
    • Timing preciso e monitoramento

  2. Pratique casos edge:

    • 1 filĂłsofo
    • 2 filĂłsofos
    • NĂșmeros grandes (200+ filĂłsofos)
    • Timing muito apertado

  3. Otimize:

    • Minimize tempo dentro de locks
    • Balance entre precisĂŁo e performance
    • Evite busy waiting

  4. Teste rigorosamente:

    valgrind --tool=helgrind ./philo 4 410 200 200
valgrind --leak-check=full ./philo 5 800 200 200 7

  5. Prepare para o projeto real:

    • Norminette
    • Makefile correto
    • Error handling robusto
    • CĂłdigo limpo e documentado

Boa sorte! 🚀