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

Question

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

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

Answer 1

Voir cette question pour discussion.

Ils recommandent les articles: Exploration de la jungle du framework de test unitaire C ++ , par Noel Llopis. Et le plus récent: Cadres d'unité de test C ++

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

Answer 2

Un nouveau lecteur est le test Google (également appelé Framework de test Google C ++). ) 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
• Fatal et affirmations 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 détaillé)
• SCOPED_TRACE pour les boucles de sous-programme
• Vous pouvez choisir les tests à exécuter
• XML génération du rapport de test
• Calendrier / Mock / Modèles ...

Answer 3

Je viens de pousser mon propre framework, CATCH , ailleurs. Il est encore en 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 coup d'oeil à mon entrée de blog liée pour un avant-goût. Mes cinq principales fonctionnalités sont les suivantes:

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

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

.

Answer 4

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%
}

Il prend en charge:

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

PS: J'ai écrit un article à ce sujet qui pourrait vous aider à démarrer: Framework de test unitaire C ++ : Tutoriel de test Boost

Answer 5

Wikipedia possède une liste complète des frameworks de test unitaire , avec des tableaux identifiant les fonctionnalités prises en charge ou non. .

Answer 6

Je viens de publier xUnit ++ , plus précisément comme alternative à Google Test et à la bibliothèque de tests Boost (voir la 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
• Automatique enregistrement du test
• De nombreux types d'assertion (Boost n'a rien sur xUnit ++)
• Compare les collections de manière native.
• Les assertions se répartissent en trois niveaux:
  • erreurs fatales
  • erreurs non fatales
  • avertissements
Journalisation
• Facile assert : Assert.Equal(-1, foo(i)) << "Failed with i = " << i;
Journalisation
• Test : Log.Debug << "Starting test"; Log.Warn << "Here's a warning";
• Calendrier
• tests basés sur les données (théories)
• Sélectionnez les tests à exécuter en fonction de:
  • Correspondance d'attribut
  • Correspondance de sous-chaîne de nom
  • Suites de test

Answer 7

CppUTest - très beau cadre léger avec des bibliothèques factices. Cela vaut la peine de regarder de plus près.

Answer 8

CPUnit ( http://cpunit.sourceforge.net ) est un cadre 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 de macro habituel. 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 l'utilisation de ce cadre très semblable à celle de JUnit, pour ceux qui ont dû passer du temps à programmer Java. Très sympa!

Answer 9

Il existe des ressources de test d'unité C ++ pertinentes à l'adresse http://www.progweap.com/resources.html

Answer 10

vérificateur de cohérence des API & # 8212; framework de test pour les bibliothèques C / C ++:

  

Un générateur automatique de tests unitaires de base pour une bibliothèque partagée C / C ++. Il est capable de générer des données d'entrée pour des paramètres raisonnables (dans la plupart des cas, mais malheureusement pas dans tous les cas), et de composer une qualité simple (& "; Santé mentale &" Ou & "Superficielle &"). ) des cas de test pour chaque fonction de l'API via l'analyse des déclarations dans les fichiers d'en-tête.

     

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 construire et d'exécuter des tests générés et de détecter des plantages (segfaults), des abandons, toutes sortes de signaux émis, des codes de retour de programmes non nuls et des suspensions de programmes.

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

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