Comparaison des frameworks de test unitaires c ++

Voir cette question pour une discussion.

Ils recommandent les articles: Exploration de la jungle du cadre de test des unités C ++ , par Noel Llopis. Et le plus récent: Frameworks C ++ Test Unit

Je n’ai pas trouvé d’article qui compare le googletest aux autres frameworks.

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

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

Caractéristiques principales:

• Portable
• Affirmations fatales et non fatales
• Messages informatifs d'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-programmes
• Vous pouvez décider quels tests exécuter
• Génération de rapport de test XML
• Fixtures / Mock / Templates ...

Je viens de repousser mon propre cadre, CATCH . Il est encore en développement mais je pense qu’il dépasse déjà la plupart des autres frameworks. Différentes personnes ont des critères différents, mais j’ai essayé de couvrir la plupart des problèmes sans trop de compromis. Jetez un oeil à mon entrée de blog liée pour un dégustateur. Mes cinq principales caractéristiques sont les suivantes:

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

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

Boost Test Library 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_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
• Beaucoup d’assertions
• Comparaison automatique des collections
• Différents formats de sortie (y compris XML )
• Fixtures / Templates …

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

Wikipedia propose une liste complète des frameworks de tests unitaires , avec des tables identifiant les fonctionnalités sockets en charge ou non.

J’ai récemment publié xUnit ++ , en particulier comme alternative à Google Test et à la Boost Test Library (voir les comparaisons ). Si vous êtes familier avec 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 sont exécutés simultanément .
• Portable
• Enregistrement de test automatique
• Beaucoup de types d'assertion (Boost n'a rien sur xUnit ++)
• Compare les collections en mode natif.
• Les assertions existent en trois niveaux:
  • erreurs fatales
  • erreurs non fatales
  • avertissements
• Assert.Equal(-1, foo(i)) << "Failed with i = " << i; facile: Assert.Equal(-1, foo(i)) << "Failed with i = " << i;
• Test logging: Log.Debug << "Starting test"; Log.Warn << "Here's a warning"; 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 de:
  • Correspondance d'atsortingbut
  • Nom sous-chaîne matchin
  • Suites de test

CppUTest – très beau cadre léger avec des bibliothèques simulées. Cela 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 le piège macro habituel. Les tests ressemblent à:

 #include  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. Ensuite, il suffit de comstackr et d’exécuter. Je trouve que l’utilisation de ce framework ressemble beaucoup à l’utilisation de JUnit, pour ceux qui ont passé du temps à programmer Java. Très agréable!

Il existe des ressources de test unitaires 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 toutes) pour les parameters et de composer des scénarios de test simples (“sanity” ou “shallow”) pour chaque fonction de l’API. des dossiers.

La qualité des tests générés permet de vérifier l’absence d’erreurs critiques dans les 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 accidents (segfaults), les abandons, toutes sortes de signaux émis, le code de retour de programme non nul et le blocage de programme.

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

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