Système Avancé - Project Template

Projet en C avec infrastructure complète: tests, benchmarks, fuzzing, CI/CD.

Pré-requis

• Compilateur: clang (version 15+)
• CMake: version 3.20+
• Ninja: pour les builds rapides (recommandé)
• Outils optionnels:
  • valgrind (pour les tests de mémoire)
  • lcov/genhtml (pour la couverture de code)
  • clang-tidy (pour l'analyse statique)

Installation sur Ubuntu/Debian

sudo apt-get update
sudo apt-get install -y clang cmake ninja-build valgrind lcov clang-tidy

Commandes Rapides

Développement quotidien (Debug avec tests)

# Configuration et build
cmake -S . -B build/debug -DCMAKE_BUILD_TYPE=Debug -DBUILD_TESTING=ON -DENABLE_SANITIZERS=ON -G Ninja
cmake --build build/debug --parallel

# Exécuter les tests
cd build/debug && ctest --output-on-failure

Nettoyer tout

rm -rf build/

---

Configuration du Projet

Build Debug complet (tests + sanitizers + coverage)

cmake -S . -B build/debug \
  -DCMAKE_BUILD_TYPE=Debug \
  -DBUILD_TESTING=ON \
  -DBUILD_BENCHMARKS=ON \
  -DENABLE_COVERAGE=ON \
  -DENABLE_SANITIZERS=ON \
  -G Ninja

cmake --build build/debug --parallel

Build Release (pour benchmarks optimisés)

cmake -S . -B build/release \
  -DCMAKE_BUILD_TYPE=Release \
  -DBUILD_TESTING=OFF \
  -DBUILD_BENCHMARKS=ON \
  -G Ninja

cmake --build build/release --parallel

Build pour Fuzzing

cmake -S . -B build/fuzz \
  -DCMAKE_BUILD_TYPE=Debug \
  -DBUILD_FUZZING=ON \
  -G Ninja

cmake --build build/fuzz --parallel

---

Exécution des Tests

Tests standards

cd build/debug
ctest --output-on-failure

Tests avec output détaillé

cd build/debug
ctest --output-on-failure --verbose

# Ou exécuter un test spécifique
./example_test

Tests avec Valgrind (détection de fuites mémoire)

cd build/debug
ctest -T MemCheck --output-on-failure

Tests avec sanitizers (détection automatique pendant le build)

Les sanitizers (AddressSanitizer, UndefinedBehaviorSanitizer) sont activés par défaut en Debug. Les erreurs s'affichent directement dans la console lors de l'exécution des tests.

---

Analyse de Couverture de Code

# Générer le rapport
cd build/debug
make coverage

# Le rapport HTML est disponible ici:
firefox build/debug/coverage_html/index.html

---

Benchmarks

# Builder en Release pour des résultats fiables
cmake -S . -B build/release -DCMAKE_BUILD_TYPE=Release -DBUILD_BENCHMARKS=ON -G Ninja
cmake --build build/release --parallel

# Exécuter tous les benchmarks
cd build/release
ctest --output-on-failure -L benchmark

# Ou exécuter un benchmark spécifique
./example_bench

---

Fuzzing

# Build avec fuzzing
cmake -S . -B build/fuzz -DCMAKE_BUILD_TYPE=Debug -DBUILD_FUZZING=ON -G Ninja
cmake --build build/fuzz --parallel

# Exécuter les tests de fuzzing (avec timeout pour éviter boucle infinie)
cd build/fuzz
timeout 60 ctest --output-on-failure -L fuzz

# Ou exécuter un fuzzer spécifique
./example_fuzz

---

Analyse Statique avec clang-tidy

# Via CMake (recommandé - vérifie pendant la compilation)
cmake -S . -B build/lint \
  -DCMAKE_C_COMPILER=clang \
  -DCMAKE_C_CLANG_TIDY=clang-tidy \
  -G Ninja
cmake --build build/lint

# Ou manuellement sur des fichiers spécifiques
clang-tidy src/*.c -- -Iinclude

---

Analyse avec Cachegrind (profilage mémoire/cache)

# Exécuter un programme avec cachegrind
valgrind --tool=cachegrind ./build/debug/example_test

# Analyser les résultats
cg_annotate cachegrind.out.* > analysis.txt
cat analysis.txt

# Visualiser avec kcachegrind (interface graphique)
kcachegrind cachegrind.out.*

---

Docker

Build de l'image Docker

docker build -t systeme-avancee:latest .

Exécuter les tests dans Docker

docker run --rm systeme-avancee:latest

Shell interactif dans Docker

docker run --rm -it systeme-avancee:latest /bin/bash

---

Structure du Projet

.
├── CMakeLists.txt          # Configuration CMake principale
├── Dockerfile              # Image Docker pour CI et builds
├── .clang-tidy             # Configuration clang-tidy
├── .clang-format           # Configuration du formatage de code
├── .github/workflows/      # CI GitHub Actions
│   └── ci.yml              # Workflow complet (tests, valgrind, cachegrind, fuzzing)
├── cmake/
│   └── valgrind.supp       # Suppressions Valgrind (faux positifs)
├── include/                # Headers publics
├── src/                    # Sources du projet
├── tests/                  # Tests unitaires
│   └── *_test.c
├── benchmarks/             # Benchmarks
│   └── *_bench.c
└── fuzzing/                # Tests de fuzzing
    └── *_fuzz.c

---

Options CMake

Option	Défaut	Description
BUILD_TESTING	ON	Construire les tests
BUILD_BENCHMARKS	ON	Construire les benchmarks
BUILD_FUZZING	OFF	Construire les cibles de fuzzing
ENABLE_COVERAGE	OFF	Activer la couverture de code (gcov/lcov)
ENABLE_SANITIZERS	ON	Activer AddressSanitizer et UBSan

---

CI/CD

Le workflow GitHub Actions exécute:

• Lint: clang-tidy sur tout le code
• Tests Debug: Unit tests + sanitizers
• Valgrind: Tests de mémoire
• Benchmarks: Performance en Release
• Fuzzing: Tests de fuzzing (timeout 60s)
• Docker: Build de l'image
• Cachegrind: Analyse performance

Les artefacts (rapports) sont disponibles dans l'interface GitHub.

---

Formatage du Code

# Formatter tous les fichiers C
clang-format -i src/*.c include/*.h tests/*.c

# Vérifier le formatage sans modifier
clang-format --dry-run --Werror src/*.c