Gerenciador de Arquivos

Este projeto contém um sistema de gerenciamento de arquivos em C com suporte completo a testes automatizados e desfragmentação de disco.

Estrutura do Projeto

├── src/                      # Código-fonte organizado
│   ├── gerenciador.h         # Header com declarações principais
│   ├── gerenciador_core.c    # Biblioteca principal com todas as funções
│   ├── main.c                # Programa principal (interface do usuário)
│   ├── test_main.c           # Testes usando a biblioteca real (RECOMENDADO)
│   ├── test_completo.c       # Testes independentes (LEGADO)
│   ├── test_gerenciador.c    # Testes modulares (desenvolvimento)
│   └── main_monolitico_backup.c # Backup da versão monolítica original
├── output/                   # Diretório para arquivos compilados
│   ├── main.exe              # Executável principal
│   ├── test_main.exe         # Executável de testes (usa código real)
│   └── test_completo.exe     # Executável de testes independentes
├── .vscode/                  # Configurações VS Code
│   └── tasks.json            # Tasks de build integradas
├── Makefile                  # Sistema de build automatizado
└── README.md                 # Este arquivo

Sistema de Build

O projeto utiliza uma arquitetura modular onde:

• gerenciador_core.c: Contém todas as funções de negócio
• main.c: Contém apenas a interface do usuário e loop principal
• test_main.c: Testa o código real via linking (MELHOR PRÁTICA)
• test_completo.c: Versão independente para comparação

Comandos disponíveis:

Compilação:

make windows          # Compila para Windows (gera .exe)
make all             # Compila versão Unix/Linux  
make clean           # Remove todos os arquivos compilados

Execução:

make run-windows     # Executa o programa principal no Windows
make test-windows    # Executa os testes (usa biblioteca real) - RECOMENDADO
make test-completo-windows # Executa testes independentes (legado)
make run             # Executa versão Unix/Linux
make test            # Executa testes Unix/Linux

Como Executar

Executar o programa principal:

./main

Compilação Manual:

Se preferir compilar manualmente:

# Programa principal (interface + biblioteca)
gcc -Wall -Wextra -std=c99 -o output/main.exe src/main.c src/gerenciador_core.c

# Testes que usam a biblioteca real (RECOMENDADO)
gcc -Wall -Wextra -std=c99 -o output/test_main.exe src/test_main.c src/gerenciador_core.c

# Testes independentes (para comparação)
gcc -Wall -Wextra -std=c99 -o output/test_completo.exe src/test_completo.c

Vantagens da Nova Arquitetura

• ✅ Modularidade: Separação clara entre lógica de negócio e interface
• ✅ Testabilidade: Testes usam exatamente o mesmo código de produção
• ✅ Manutenibilidade: Mudanças na biblioteca automaticamente afetam testes
• ✅ Reutilização: Biblioteca pode ser usada em outros projetos
• ✅ Consistência: Garante que testes validam o código real, não uma cópia

Funcionalidades

Testes Básicos:

1. Inicialização - Verifica se o sistema inicia corretamente
2. Gravar arquivo simples - Testa gravação de um arquivo pequeno
3. Gravar múltiplos arquivos - Testa gravação de vários arquivos
4. Deletar arquivo - Testa remoção de arquivo existente
5. Deletar arquivo inexistente - Testa comportamento com arquivo que não existe
6. Verificação nome duplicado - Impede gravação de arquivos com mesmo nome

Testes Avançados:

1. Espaço insuficiente - Testa comportamento quando não há espaço suficiente
2. Fragmentação e reuso - Testa se o sistema reutiliza espaços liberados
3. Arquivo exato um setor - Testa arquivo que ocupa exatamente um setor
4. Arquivo múltiplos setores - Testa arquivo que ocupa vários setores
5. Sequencial gravar/deletar - Teste de estresse com múltiplas operações

Interpretando os Resultados

• ✓ PASSOU: O teste foi executado com sucesso
• ✗ FALHOU: O teste encontrou um problema, com descrição do erro

Exemplo de saída:

=== TESTE DO GERENCIADOR DE ARQUIVOS ===

Executando testes básicos...
✓ PASSOU: Inicialização - Memória completamente livre
✓ PASSOU: Gravar arquivo simples
✓ PASSOU: Gravar múltiplos arquivos
✓ PASSOU: Deletar arquivo
✓ PASSOU: Deletar arquivo inexistente

Executando testes avançados...
✓ PASSOU: Espaço insuficiente
✓ PASSOU: Fragmentação e reuso
✓ PASSOU: Arquivo exato um setor
✓ PASSOU: Arquivo múltiplos setores
✓ PASSOU: Sequencial gravar/deletar

=== RESUMO DOS TESTES ===
Total de testes executados: 10
Testes que passaram: 10
Testes que falharam: 0

🎉 TODOS OS TESTES PASSARAM! 🎉

Estrutura dos Testes

O arquivo test_gerenciador.c inclui:

• Funções auxiliares para verificação de estado
• Setup de teste que inicializa o ambiente para cada teste
• Testes modulares que verificam funcionalidades específicas
• Relatório detalhado com estatísticas de sucesso/falha

Personalizando os Testes

Para adicionar novos testes:

1. Crie uma função void teste_nova_funcionalidade()
2. Use setup_teste() para inicializar o ambiente
3. Execute as operações que deseja testar
4. Use imprimir_resultado_teste() para reportar o resultado
5. Adicione a chamada da função na main()

Depuração

Se algum teste falhar, você pode:

1. Adicionar prints de debug nas funções de teste
2. Usar as funções auxiliares como mostraSetores(), mostraArquivos() e mostraMemoria()
3. Executar testes individuais comentando outros na função main()

Configurações

As constantes do sistema são definidas no início dos arquivos:

• TAMGRANULO 3 - Tamanho de cada setor em caracteres
• TAMMEMORIA 30 - Número total de setores disponíveis

Autores:

• Flávia Marcella Gonçalves Moreira: 2024.1.08.025
• Larissa Rodrigues de Ávila: 2024.1.08.031
• Vinicius Ribeiro da Silva do Carmo: 2023.2.08.003