Ce fichier contient des tests unitaires pour la classe ThreadPool en utilisant GoogleTest. Les tests vérifient les fonctionnalités de base de la classe ThreadPool, y compris l'exécution des tâches, la gestion de multiples tâches, l'exécution différée des tâches et le comportement après l'arrêt du pool de threads.

Test pour vérifier l'exécution des tâches de base.

TEST(ThreadPoolTest, TaskExecution) {
    ThreadPool pool(4);

    auto task1 = pool.enqueue([] { return 1 + 1; });
    auto task2 = pool.enqueue([](int a, int b) { return a + b; }, 2, 3);

    EXPECT_EQ(task1.get(), 2);
    EXPECT_EQ(task2.get(), 5);
}

• Objectif : Vérifier que les tâches de base sont exécutées correctement par le pool de threads.
• Assertions :
  • EXPECT_EQ(task1.get(), 2) : Vérifie que la première tâche retourne 2.
  • EXPECT_EQ(task2.get(), 5) : Vérifie que la deuxième tâche retourne 5.

Test pour vérifier la gestion de multiples tâches.

TEST(ThreadPoolTest, MultipleTasks) {
    ThreadPool pool(4);
    std::vector<std::future<int>> results;

    for (int i = 0; i < 8; ++i) {
        results.emplace_back(pool.enqueue([i] { return i * i; }));
    }

    for (int i = 0; i < 8; ++i) {
        EXPECT_EQ(results[i].get(), i * i);
    }
}

• Objectif : Vérifier que le pool de threads peut gérer plusieurs tâches simultanément.
• Assertions :
  • Vérifie que chaque tâche retourne le carré de son index.

Test pour vérifier l'exécution différée des tâches.

TEST(ThreadPoolTest, DelayedTaskExecution) {
    ThreadPool pool(4);

    auto start = std::chrono::high_resolution_clock::now();
    auto task = pool.enqueue([] {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        return 42;
    });

    EXPECT_EQ(task.get(), 42);
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();

    EXPECT_GE(duration, 100);
}

• Objectif : Vérifier que le pool de threads peut gérer l'exécution différée des tâches.
• Assertions :
  • EXPECT_EQ(task.get(), 42) : Vérifie que la tâche retourne 42.
  • EXPECT_GE(duration, 100) : Vérifie que la tâche a attendu au moins 100 millisecondes avant de terminer.

Test pour vérifier le comportement du pool de threads après l'arrêt. (Commenté car peut-être non implémenté ou problématique)

/*
TEST(ThreadPoolTest, Shutdown) {
    ThreadPool pool(4);

    auto task = pool.enqueue([] {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        return 42;
    });

    pool.shutdown();
    EXPECT_EQ(task.get(), 42);
}

• Objectif : Vérifier que le pool de threads termine correctement les tâches en cours après l'arrêt. (Commenté pour l'instant)

Test pour vérifier le comportement lorsqu'une tâche est ajoutée après l'arrêt du pool de threads. (Commenté car peut-être non implémenté ou problématique)

/*
TEST(ThreadPoolTest, EnqueueAfterShutdown) {
    ThreadPool pool(4);
    pool.shutdown();

    EXPECT_THROW(pool.enqueue([] { return 1; }), std::runtime_error);
}

• Objectif : Vérifier que le pool de threads ne permet pas l'ajout de nouvelles tâches après l'arrêt. (Commenté pour l'instant)

☝️🤓Ces tests unitaires garantissent que la classe ThreadPool fonctionne comme prévu en termes d'exécution des tâches, de gestion de multiples tâches, et d'exécution différée des tâches. En utilisant GoogleTest, ces tests fournissent une validation automatique et fiable des fonctionnalités de la classe.☝️🤓