✅ Catch2

Description

• Origine 🌱 Catch2 est la suite de Catch (l'acronyme pour "C++ Automated Test Cases in Headers"). Il a été conçu pour offrir une simplicité d'utilisation tout en évitant les complications des étapes de compilation principales.
• De "Header-only" à une bibliothèque traditionnelle 🔄 Bien que les versions précédentes de Catch aient été "header-only", la version 3 apporte des changements significatifs. Le plus notable est que Catch2 n'est plus une bibliothèque en un seul en-tête. À partir de la v3, Catch2 se comporte comme une bibliothèque traditionnelle, avec plusieurs en-têtes et une implémentation compilée séparément.
• Simplicité 🎯 Malgré ce changement majeur, la philosophie principale de Catch2 reste la même : offrir un moyen simple et naturel d'écrire des tests sans sacrifier la fonctionnalité.
• Sections et BDD 🧪 Catch2 introduit le concept de "sections", permettant de diviser un test en plusieurs étapes ou scénarios. Il supporte également une syntaxe inspirée de BDD (Behavior-Driven Development) avec des mots-clés tels que Given, When, et Then, améliorant la lisibilité des tests.
• Reporting riche 📊 Catch2 fournit des rapports détaillés et configurables, et supporte plusieurs formats de sortie pour s'intégrer facilement à d'autres outils ou systèmes CI/CD.
• Compatibilité 🔄 Bien qu'il ait évolué, Catch2 reste compatible avec les dernières normes C++ et fonctionne avec de nombreux compilateurs, le rendant idéal pour les projets modernes.
• Extensions 🔌 Le framework peut être étendu grâce à divers reporters, listeners et même avec des frameworks de mocking pour s'adapter aux besoins spécifiques du projet.
• Communauté 🧑‍🤝‍🧑 La popularité et l'évolution de Catch2 ont conduit à une communauté active, contribuant régulièrement à son développement et fournissant un soutien aux utilisateurs.

En synthèse, Catch2, avec ses mises à jour dans la v3, demeure un framework de test robuste pour C++, combinant simplicité et flexibilité. Il s'adapte aux besoins changeants des développeurs, tout en fournissant un outil de test efficace et fiable. 🛠️🧠🔬

Windows : Installation

Mon script

• Des répertoires différents pour les versions debug/release
• La possibilité du choix d’utiliser ensuite les DLL ou les versions statiques

  # Définir les chemins et les variables pour le téléchargement et l'installation de la bibliothèque
  $BASE_PATH = "D:\Coding\Frameworks"
  $NAME_LIBRARY = "Catch2"
  $LIBRARY_VERSION = "3.8.1"
  $DOWNLOAD_URL = "https://github.com/catchorg/Catch2/archive/refs/tags/v${LIBRARY_VERSION}.zip"
  
  # compiler le chemin de base pour la bibliothèque
  $BASE_LIBRARY_PATH = Join-Path -Path $BASE_PATH -ChildPath "$NAME_LIBRARY"
  
  # compiler le chemin vers la version spécifique de la bibliothèque
  $VERSION_LIBRARY_PATH = Join-Path -Path $BASE_LIBRARY_PATH -ChildPath "$LIBRARY_VERSION"
  
  # Définir le nom du répertoire extrait et le nom de l'archive
  $EXTRACTED_DIR_NAME = "Catch2-${LIBRARY_VERSION}"
  $ARCHIVE_NAME = "v${LIBRARY_VERSION}.zip"
  $INSTALLATION_DIR = "${BASE_PATH}\${NAME_LIBRARY}\${LIBRARY_VERSION}"
  
  # compiler le chemin complet vers l'archive ZIP
  $ZIP_PATH = Join-Path -Path $BASE_LIBRARY_PATH -ChildPath $ARCHIVE_NAME
  
  New-Item -ItemType Directory -Path $BASE_LIBRARY_PATH -Force
  Set-Location -Path $BASE_LIBRARY_PATH
  
  # Télécharger l'archive ZIP depuis l'URL spécifiée
  Invoke-WebRequest -Uri $DOWNLOAD_URL -OutFile $ZIP_PATH
  
  # Ajouter la capacité de décompresser des fichiers ZIP
  Add-Type -AssemblyName System.IO.Compression.FileSystem
  # Extraire l'archive ZIP au chemin de la bibliothèque
  [System.IO.Compression.ZipFile]::ExtractToDirectory($ZIP_PATH, $BASE_LIBRARY_PATH)
  
  # Renommer le répertoire extrait pour qu'il corresponde à la version de la bibliothèque
  $OLD_DIR = Join-Path -Path $BASE_LIBRARY_PATH -ChildPath $EXTRACTED_DIR_NAME
  Rename-Item -Path $OLD_DIR -NewName ($LIBRARY_VERSION)
  
  # Supprimer l'archive ZIP une fois qu'elle n'est plus nécessaire
  Remove-Item -Path $ZIP_PATH
  
  Set-Location -Path $VERSION_LIBRARY_PATH
  
  # Fonction pour compiler et installer la bibliothèque
  function BuildAndInstallLibrary($build_directory, $config, $sharedLibs) {
      $directory = Join-Path -Path $VERSION_LIBRARY_PATH -ChildPath $build_directory
      # Créer un répertoire pour la construction
      New-Item -ItemType Directory -Path $directory -Force
      Set-Location -Path $directory
  
      $cmakeArgs = @(
          "..",
          "-DBUILD_TESTING=OFF",
          "-DCMAKE_INSTALL_PREFIX=${VERSION_LIBRARY_PATH}",
          "-DCMAKE_BUILD_TYPE=$config",
          "-DBUILD_SHARED_LIBS=$sharedLibs"
      )
  
      # Run cmake with the arguments
      & cmake $cmakeArgs
      & cmake --build . --config $config
      & cmake --install . --config $config
  }
  
  # Utilisation de la fonction pour compiler et installer la bibliothèque dans différentes configurations
  BuildAndInstallLibrary "build_debug" "Debug" "OFF"
  BuildAndInstallLibrary "build_release" "Release" "OFF"
  BuildAndInstallLibrary "build_debug_dll" "Debug" "ON"
  BuildAndInstallLibrary "build_release_dll" "Release" "ON"
  

CMakeLists.txt

# Spécifie la version minimale requise de CMake pour exécuter ce script.
cmake_minimum_required(VERSION 3.26)

# Nomme le projet "Catch2_testing".
project(Catch2_testing)

# Fixe la version du standard C++ utilisée à C++23.
set(CMAKE_CXX_STANDARD 23)

# Définit le chemin de base pour Catch2.
set(CATCH2_BASE_PATH "D:/Coding/Frameworks/Catch2/3.8.1")

# Indique si Catch2 est utilisé en tant que DLL (bibliothèque dynamique) ou non.
SET(USE_DYNAMIC_CATCH2 ON)

# Affiche le type de build (Debug, Release, etc.).
MESSAGE("Type: ${CMAKE_BUILD_TYPE}")

# Si Catch2 est utilisé comme une DLL.
if (USE_DYNAMIC_CATCH2)
    MESSAGE("Link: Dynamic (DLL)")
    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
        set(CATCH2_DLL_PATH "${CATCH2_BASE_PATH}/build_debug_dll/src/Debug")
    else ()
        set(CATCH2_DLL_PATH "${CATCH2_BASE_PATH}/build_release_dll/src/Release")
    endif ()

    # Définit le répertoire de destination pour les DLLs.
    set(DLL_DEST_DIR ${CMAKE_BINARY_DIR})
    MESSAGE("Copy the DLLs to the executable directory : ${DLL_DEST_DIR}")

    # Récupère tous les fichiers DLL du chemin spécifié.
    file(GLOB CATCH2_DLLS "${CATCH2_DLL_PATH}/*.dll")
    # Boucle pour copier chaque DLL dans le répertoire d'exécution.
    foreach (DLL ${CATCH2_DLLS})
        get_filename_component(DLL_NAME ${DLL} NAME)
        MESSAGE("DLL : ${DLL_NAME}")
        configure_file("${CATCH2_DLL_PATH}/${DLL_NAME}" "${DLL_DEST_DIR}/${DLL_NAME}" COPYONLY)
    endforeach ()
else ()
    MESSAGE("Link: Static")
endif ()

# Ajoute le chemin de base de Catch2 à CMAKE_PREFIX_PATH pour faciliter la recherche de paquets.
list(APPEND CMAKE_PREFIX_PATH ${CATCH2_BASE_PATH})

# Ajoute le répertoire d'en-tête de Catch2 aux répertoires d'inclusion du projet.
include_directories("${CATCH2_BASE_PATH}/include")

# Recherche le paquet Catch2 version 3 et indique qu'il est obligatoire.
find_package(Catch2 3 REQUIRED)

# Ajoute un exécutable nommé "Catch2_testing" avec "main.cpp" comme source.
add_executable(Catch2_testing main.cpp)

if (USE_DYNAMIC_CATCH2)
    target_link_libraries(Catch2_testing PRIVATE Catch2::Catch2WithMain)
else ()
    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
        target_link_libraries(Catch2_testing PRIVATE
                "${CATCH2_BASE_PATH}/build_debug/src/Debug/Catch2Maind.lib"
                "${CATCH2_BASE_PATH}/build_debug/src/Debug/Catch2d.lib")
    else ()
        target_link_libraries(Catch2_testing PRIVATE
                "${CATCH2_BASE_PATH}/build_release/src/Release/Catch2Main.lib"
                "${CATCH2_BASE_PATH}/build_release/src/Release/Catch2.lib")
    endif ()
endif ()

Linux : Installation

Mon Script

#!/bin/bash
# -------------------------------------------------------------------------------
# Installation automatisée de Catch2 3.8.1 sur Debian / Ubuntu
# -------------------------------------------------------------------------------

# 1. Mise à jour du système et installation des dépendances indispensables
sudo apt update && sudo apt upgrade -y
sudo apt install -y build-essential cmake ninja-build tar wget

# 2. Définition des variables liées à Catch2 3.8.1
ROOT_PATH="/opt/catch2"                     # Dossier racine pour toutes les versions de Catch2
LIBRARY_NAME="Catch2"                       # Nom logique de la bibliothèque
LIBRARY_VERSION="3.8.1"                     # Version x.y.z
ARCHIVE_NAME="v${LIBRARY_VERSION}.tar.gz"   # Nom de l’archive source
EXTRACTED_DIR_NAME="${LIBRARY_NAME}-${LIBRARY_VERSION}"  # Dossier après extraction
DOWNLOAD_URL="https://github.com/catchorg/Catch2/archive/refs/tags/${ARCHIVE_NAME}"

INSTALL_PREFIX="${ROOT_PATH}/${LIBRARY_VERSION}"  # Sera passé à CMake : installation isolée

# 3. Création du répertoire racine puis déplacement dans celui-ci
sudo mkdir -p "${ROOT_PATH}"
cd "${ROOT_PATH}" || { echo "Erreur : impossible d’accéder à ${ROOT_PATH}" >&2; exit 1; }

# 4. Téléchargement de l’archive Catch2 3.8.1
wget "${DOWNLOAD_URL}"

# 5. Suppression d’une éventuelle installation antérieure de la même version
sudo rm -rf "${LIBRARY_VERSION}"

# 6. Extraction de l’archive .tar.gz
tar -xzf "${ARCHIVE_NAME}"

# 7. Renommage du dossier extrait pour refléter directement la version
mv "${EXTRACTED_DIR_NAME}" "${LIBRARY_VERSION}"

# 8. Nettoyage : suppression de l’archive source pour gagner de l’espace
rm "${ARCHIVE_NAME}"

# 9. Passage dans le répertoire source de Catch2
cd "${LIBRARY_VERSION}" || { echo "Erreur : impossible d’accéder à ${LIBRARY_VERSION}" >&2; exit 1; }

# 10. Définition des options CMake communes
CMAKE_BASE_OPTIONS="-DBUILD_TESTING=OFF -DCMAKE_INSTALL_PREFIX=${INSTALL_PREFIX}"

# 11. Compilation — quatre variantes
#     * Debug   statique
#     * Release statique
#     * Debug   partagée
#     * Release partagée

# 11-a Debug statique
mkdir build_debug && cd build_debug
cmake .. ${CMAKE_BASE_OPTIONS} -DCMAKE_BUILD_TYPE=Debug   -DBUILD_SHARED_LIBS=OFF
cmake --build . --config Debug
cmake --install . --config Debug
cd ..

# 11-b Release statique
mkdir build_release && cd build_release
cmake .. ${CMAKE_BASE_OPTIONS} -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=OFF
cmake --build . --config Release
cmake --install . --config Release
cd ..

# 11-c Debug partagée
mkdir build_debug_so && cd build_debug_so
cmake .. ${CMAKE_BASE_OPTIONS} -DCMAKE_BUILD_TYPE=Debug   -DBUILD_SHARED_LIBS=ON
cmake --build . --config Debug
cmake --install . --config Debug
cd ..

# 11-d Release partagée
mkdir build_release_so && cd build_release_so
cmake .. ${CMAKE_BASE_OPTIONS} -DCMAKE_BUILD_TYPE=Release -DBUILD_SHARED_LIBS=ON
cmake --build . --config Release
cmake --install . --config Release
cd ..

# -------------------------------------------------------------------------------
# Fin de l’installation de Catch2 3.8.1 — bibliothèques statiques et partagées
#     * Fichiers installés sous : ${INSTALL_PREFIX}
# -------------------------------------------------------------------------------

CMakeLists.txt

# Spécifie la version minimale requise de CMake pour exécuter ce script.
cmake_minimum_required(VERSION 3.26)

# Nomme le projet "Catch2_testing".
project(Catch2_testing)

# Fixe la version du standard C++ utilisée à C++23.
set(CMAKE_CXX_STANDARD 23)

# Définit le chemin de base pour Catch2.
set(CATCH2_BASE_PATH "/opt/catch2/3.8.1")

# Indique si Catch2 est utilisé en tant que DLL (bibliothèque dynamique) ou non.
SET(USE_DYNAMIC_CATCH2 OFF)

# Affiche le type de build (Debug, Release, etc.).
MESSAGE("Type: ${CMAKE_BUILD_TYPE}")

# Si Catch2 est utilisé comme une DLL.
if (USE_DYNAMIC_CATCH2)
    MESSAGE("Link: Dynamic (SO)")
    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
        set(CATCH2_DLL_PATH "${CATCH2_BASE_PATH}/build_debug_so/src")
    else ()
        set(CATCH2_DLL_PATH "${CATCH2_BASE_PATH}/build_release_so/src")
    endif ()

    # Définit le répertoire de destination pour les DLLs.
    set(DLL_DEST_DIR ${CMAKE_BINARY_DIR})
    MESSAGE("Copy the SO files to the executable directory : ${DLL_DEST_DIR}")
    MESSAGE("${CATCH2_DLL_PATH}/*.so")


    # Récupère tous les fichiers DLL du chemin spécifié.
    file(GLOB CATCH2_DLLS "${CATCH2_DLL_PATH}/*.so")
    # Boucle pour copier chaque DLL dans le répertoire d'exécution.
    foreach (DLL ${CATCH2_DLLS})
        get_filename_component(DLL_NAME ${DLL} NAME)
        MESSAGE("SO File : ${DLL_NAME}")
        configure_file("${CATCH2_DLL_PATH}/${DLL_NAME}" "${DLL_DEST_DIR}/${DLL_NAME}" COPYONLY)
    endforeach ()
else ()
    MESSAGE("Link: Static")
endif ()

# Ajoute le chemin de base de Catch2 à CMAKE_PREFIX_PATH pour faciliter la recherche de paquets.
list(APPEND CMAKE_PREFIX_PATH ${CATCH2_BASE_PATH})

# Ajoute le répertoire d'en-tête de Catch2 aux répertoires d'inclusion du projet.
include_directories("${CATCH2_BASE_PATH}/include")

# Recherche le paquet Catch2 version 3 et indique qu'il est obligatoire.
find_package(Catch2 3 REQUIRED)

# Ajoute un exécutable nommé "Catch2_testing" avec "main.cpp" comme source.
add_executable(Catch2_testing main.cpp)

if (USE_DYNAMIC_CATCH2)
    target_link_libraries(Catch2_testing PRIVATE Catch2::Catch2WithMain)
else ()
    if (CMAKE_BUILD_TYPE STREQUAL "Debug")
        target_link_libraries(Catch2_testing PRIVATE
                "${CATCH2_BASE_PATH}/build_debug/src/libCatch2Maind.a"
                "${CATCH2_BASE_PATH}/build_debug/src/libCatch2d.a")
    else ()
        target_link_libraries(Catch2_testing PRIVATE
                "${CATCH2_BASE_PATH}/build_release/src/libCatch2Main.a"
                "${CATCH2_BASE_PATH}/build_release/src/libCatch2.a")
    endif ()
endif ()

Programme test

#include <catch2/catch_test_macros.hpp>

unsigned int Factorial( unsigned int number ) {
    return number <= 1 ? number : Factorial(number-1)*number;
}

TEST_CASE( "Factorials are computed", "[factorial]" ) {
    REQUIRE( Factorial(1) == 1 );
    REQUIRE( Factorial(2) == 2 );
    REQUIRE( Factorial(3) == 6 );
    REQUIRE( Factorial(10) == 3628800 );
}

TEST_CASE( "vectors can be sized and resized", "[vector]" ) {

    std::vector<int> v( 5 );

    REQUIRE( v.size() == 5 );
    REQUIRE( v.capacity() >= 5 );

    SECTION( "resizing bigger changes size and capacity" ) {
        v.resize( 10 );

        REQUIRE( v.size() == 10 );
        REQUIRE( v.capacity() >= 10 );
    }

    SECTION( "resizing smaller changes size but not capacity" ) {
        v.resize( 0 );

        REQUIRE( v.size() == 0 );
        REQUIRE( v.capacity() >= 5 );
    }

    SECTION( "reserving bigger changes capacity but not size" ) {
        v.reserve( 10 );

        REQUIRE( v.size() == 5 );
        REQUIRE( v.capacity() >= 10 );
    }

    SECTION( "reserving smaller does not change size or capacity" ) {
        v.reserve( 0 );

        REQUIRE( v.size() == 5 );
        REQUIRE( v.capacity() >= 5 );
    }
}