# 📊 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:
- [x] pthread_create
- [x] pthread_join
- [x] pthread_detach
- [x] Thread arguments
- [x] Multiple threads

### Synchronization:
- [x] pthread_mutex_init/destroy
- [x] pthread_mutex_lock/unlock
- [x] Critical sections
- [x] Race conditions
- [x] Deadlock prevention

### Timing:
- [x] gettimeofday
- [x] Precise sleep
- [x] Timestamp generation
- [x] Time difference calculation

### Processes (Bonus):
- [x] fork()
- [x] waitpid()
- [x] kill()
- [x] Signal handling
- [x] Process cleanup

### Semaphores (Bonus):
- [x] sem_open
- [x] sem_wait/sem_post
- [x] sem_close/sem_unlink
- [x] Named semaphores

### Philosophers-Specific:
- [x] Circular resource allocation
- [x] Death detection
- [x] Meal counting
- [x] State transitions
- [x] Monitor pattern
- [x] 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**:
   ```bash
   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! 🚀