Comparaison des frameworks de tests unitaires C ++ [fermé]

Je sais qu'il y a déjà quelques questions concernant les recommandations pour les cadres de test unitaire C ++, mais toutes les réponses n'ont pas aidé car ils recommandent simplement l'un des cadres mais ne fournissent aucune information sur une comparaison (de fonctionnalité).

Je pense que les frameworks les plus intéressants sont CppUnit, Boost et le nouveau framework de test Google. Quelqu'un a-t-il déjà fait une comparaison?

Voir cette question pour une discussion.

Ils recommandent les articles: Exploring the C ++ Unit Testing Framework Jungle , By Noel Llopis. Et le plus récent: les cadres d'unités de test C ++

Je n'ai pas encore trouvé d'article qui compare googletest aux autres frameworks.

Un nouveau lecteur est Google Test (également connu sous le nom de Google C ++ Testing Framework ), ce qui est plutôt sympa.

#include <gtest/gtest.h>

TEST(MyTestSuitName, MyTestCaseName) {
    int actual = 1;
    EXPECT_GT(actual, 0);
    EXPECT_EQ(1, actual) << "Should be equal to one";
}

Caractéristiques principales:

• Portable
• Assertions fatales et non fatales
• Messages informatifs sur les assertions faciles :ASSERT_EQ(5, Foo(i)) << " where i = " << i;
• Google Test détecte automatiquement vos tests et ne vous oblige pas à les énumérer pour les exécuter
• Facilitez l' extension de votre vocabulaire d'assertion
• Tests de décès (voir guide avancé)
• SCOPED_TRACE pour les boucles de sous-programme
• Vous pouvez décider quels tests exécuter
• Génération de rapport de test XML
• Fixtures / Mock / Templates ...

Je viens de pousser mon propre framework, CATCH , là-bas. Il est encore en cours de développement, mais je pense qu'il dépasse déjà la plupart des autres cadres. Différentes personnes ont des critères différents, mais j'ai essayé de couvrir la plupart des terrains sans trop de compromis. Jetez un oeil à mon entrée de blog liée pour un avant-goût. Mes cinq principales fonctionnalités sont:

• En-tête uniquement
• Enregistrement automatique des tests basés sur les fonctions et les méthodes
• Décompose les expressions C ++ standard en LHS et RHS (vous n'avez donc pas besoin de toute une famille de macros d'assertion).
• Prise en charge des sections imbriquées dans un appareil basé sur une fonction
• Tests de nom en langage naturel - des noms de fonction / méthode sont générés

Il dispose également de liaisons Objective-C. Le projet est hébergé sur Github

La bibliothèque de tests Boost est un très bon choix, surtout si vous utilisez déjà Boost.

// TODO: Include your class to test here.
#define BOOST_TEST_MODULE MyTest
#include <boost/test/unit_test.hpp>

BOOST_AUTO_TEST_CASE(MyTestCase)
{
    // To simplify this example test, let's suppose we'll test 'float'.
    // Some test are stupid, but all should pass.
    float x = 9.5f;

    BOOST_CHECK(x != 0.0f);
    BOOST_CHECK_EQUAL((int)x, 9);
    BOOST_CHECK_CLOSE(x, 9.5f, 0.0001f); // Checks differ no more then 0.0001%
}

Elle supporte:

• Enregistrement automatique ou manuel des tests
• De nombreuses affirmations
• Comparaison automatique des collections
• Différents formats de sortie (y compris XML )
• Luminaires / Modèles ...

PS: J'ai écrit un article à ce sujet qui pourrait vous aider à démarrer: C ++ Unit Testing Framework: A Boost Test Tutorial

Wikipedia a une liste complète de frameworks de tests unitaires , avec des tableaux qui identifient les fonctionnalités prises en charge ou non.

J'ai récemment publié xUnit ++ , spécifiquement comme une alternative à Google Test et à la bibliothèque de tests Boost (voir les comparaisons ). Si vous connaissez xUnit.Net, vous êtes prêt pour xUnit ++.

#include "xUnit++/xUnit++.h"

FACT("Foo and Blah should always return the same value")
{
    Check.Equal("0", Foo()) << "Calling Foo() with no parameters should always return \"0\".";
    Assert.Equal(Foo(), Blah());
}

THEORY("Foo should return the same value it was given, converted to string", (int input, std::string expected),
    std::make_tuple(0, "0"),
    std::make_tuple(1, "1"),
    std::make_tuple(2, "2"))
{
    Assert.Equal(expected, Foo(input));
}

Caractéristiques principales:

• Incroyablement rapide: les tests s'exécutent simultanément .
• Portable
• Enregistrement automatique des tests
• De nombreux types d'assertions (Boost n'a rien sur xUnit ++)
• Compare les collections nativement.
• Les assertions se déclinent en trois niveaux:
  • erreurs fatales
  • erreurs non fatales
  • avertissements
• Enregistrement facile des assertions :Assert.Equal(-1, foo(i)) << "Failed with i = " << i;
• Journalisation des tests :Log.Debug << "Starting test"; Log.Warn << "Here's a warning";
• Agencements
• Tests basés sur les données (théories)
• Sélectionnez les tests à exécuter en fonction:
  • Correspondance d'attribut
  • Correspondance de sous-chaîne de nom
  • Suites de test

CppUTest - un cadre très agréable et léger avec de fausses bibliothèques. Il vaut la peine de regarder de plus près.

CPUnit ( http://cpunit.sourceforge.net ) est un framework similaire à Google Test, mais qui repose sur moins de macos (les assertions sont des fonctions), et où les macros sont préfixées pour éviter l'écueil habituel des macros. Les tests ressemblent à:

#include <cpunit>

namespace MyAssetTest {
    using namespace cpunit;

    CPUNIT_FUNC(MyAssetTest, test_stuff) {
        int some_value = 42;
        assert_equals("Wrong value!", 666, some_value);
    }

    // Fixtures go as follows:
    CPUNIT_SET_UP(MyAssetTest) {
        // Setting up suite here...
        // And the same goes for tear-down.
    }

}

Ils s'enregistrent automatiquement, vous n'avez donc pas besoin de plus que cela. Ensuite, il suffit de compiler et d'exécuter. Je trouve que l'utilisation de ce framework ressemble beaucoup à l'utilisation de JUnit, pour ceux qui ont dû passer du temps à programmer Java. Très agréable!

Il existe des ressources de test unitaire C ++ pertinentes sur http://www.progweap.com/resources.html

API Sanity Checker - framework de test pour les bibliothèques C / C ++:

Un générateur automatique de tests unitaires de base pour une bibliothèque C / C ++ partagée. Il est capable de générer des données d'entrée raisonnables (dans la plupart des cas, mais malheureusement pas tous) pour les paramètres et de composer des cas de test simples (de «santé mentale» ou de «faible profondeur») pour chaque fonction de l'API grâce à l'analyse des déclarations dans l'en-tête des dossiers.

La qualité des tests générés permet de vérifier l'absence d'erreurs critiques dans des cas d'utilisation simples. L'outil est capable de créer et d'exécuter des tests générés et de détecter les plantages (erreurs de segmentation), les abandons, toutes sortes de signaux émis, le code retour de programme non nul et le blocage de programme.

Fonctionnalités uniques par rapport à CppUnit, Boost et Google Test:

• Génération automatique des données de test et des arguments d'entrée (même pour les types de données complexes)
• Types spécialisés modernes et hautement réutilisables au lieu d'appareils et de modèles