Unitaires et d'intégration et de tests en C++

La Stimuler La Bibliothèque De Test vous donne tests unitaires, etc.

Comparant CppTest et CppUnit je voudrais aller avec CppTest. CppTest a moins caché cadre et de l'OMI plus facile à comprendre et à mettre en œuvre. Personnellement, j'aime à voir la principal point d'entrée. J'ai aussi inclus Boost Framework de Test Unitaire. Il n'est pas xUnit base. Je ne suis pas un fan, mais si vous êtes déjà à l'aide de la Bibliothèque Boost, il serait bien de l'intégrer.

---

CppTest vs CppUnit

•La facilité de création d'une unité de test et d'essai
suite. Les deux CppUnit et CppTest créer
les tests unitaires des méthodes de la classe, avec l'
la classe elle-même dérivée de certains
l'outil fourni par la classe de Test. La syntaxe
pour CppTest est légèrement plus simple,
si, avec l'inscription au test
qui se passe à l'intérieur de la classe
constructeur. Dans le cas de CppUnit,
les macros supplémentaires
CPPUNIT_TEST_SUITE et
CPPUNIT_TEST_SUITE_ENDS sont nécessaires.

•Exécuter les tests. CppTest simplement
les appels de la méthode run sur le test
la suite, tout en CppUnit utilise un autre
Lanceur de classe dont la méthode run est
invoquée pour exécuter les tests.

•L'extension de la hiérarchie de test. Dans
le cas de CppTest, il est toujours
possible d'étendre le test précédent
suite par la création d'une nouvelle classe
hérite de l'ancien. La nouvelle
la classe sera de définir quelques autres
les fonctions qui s'ajoutent à l'unité de test
piscine. Vous suffit de l'appeler la méthode run
sur l'objet de la nouvelle classe type.
CppUnit, en revanche, exige que
vous utilisez la macro
CPPUNIT_TEST_SUB_SUITE avec
l'héritage de classe à atteindre le même
effet.

•Générer une sortie formatée. Les deux
CppTest et CppUnit ont la capacité
pour personnaliser la sortie. Cependant,
bien que CppTest a un utile,
HTML prédéfinis de sortie formateur,
CppUnit ne le fait pas. Cependant, CppUnit
exclusivement prend en charge la mise en forme XML.
Les deux charge de texte et un compilateur style
les formats.

•La création d'appareils de test. À des fins de test
luminaires, CppUnit exige que l'
test de la classe dérivée à partir de
CppUnit::TestFixture. Vous devez fournir
définitions pour l'installation et la
le démontage de routines. Dans le cas de
CppTest, vous devez fournir
définitions uniquement pour la configuration et le
le démontage de routines. C'est certainement l'
une meilleure solution, car elle maintient l'
code client simple. •Prédéfini
utilitaire de macro de soutien. Les Deux CppTest
et CppUnit ont un ensemble comparable de
macros pour l'affirme, la manipulation de flotteurs,
et ainsi de suite.

•Fichiers d'en-tête. CppTest exige que
vous incluez un seul fichier d'en-tête,
alors que CppUnit code client doit inclure
plusieurs en-têtes, comme HelperMacros.h
et TextTestRunner.h, en fonction de la
les fonctionnalités utilisées.

http://www.ibm.com/developerworks/aix/library/au-ctools3_ccptest/index.html?ca=drs-

---

CPPTEST

#include “cppTest.h”

class myTestWithFixtures : public Test::Suite { 
  void function1_to_test_some_code( );
  void function2_to_test_some_code( );

  public: 
  myTestWithFixtures ( ) { 
      TEST_ADD (function1_to_test_some_code) {...}; 
      TEST_ADD (function2_to_test_some_code) {...}; 
  } 

  protected: 
    virtual void setup( ) { ... };
    virtual void tear_down( ) { ... };
}; 

int main ( ) 
{ 
  myTestWithFixtures tests; 
  Test::TextOutput output(Test::TextOutput::Verbose);
  return tests.run(output);
} 

http://www.ibm.com/developerworks/aix/library/au-ctools3_ccptest/index.html?ca=drs-

---

CPPUNIT

#include <cppunit/extensions/TestFactoryRegistry.h>
#include <cppunit/ui/text/TextTestRunner.h>
#include <cppunit/extensions/HelperMacros.h>

class mystringTest : public CppUnit::TestFixture {
public:
  void setUp() { ... };
  void tearDown() { ... };

  void function1_to_test_some_code() { ... };
  void function2_to_test_some_code() { ... };

  CPPUNIT_TEST_SUITE( mystringTest );
  CPPUNIT_TEST( function1_to_test_some_code );
  CPPUNIT_TEST( function2_to_test_some_code );
  CPPUNIT_TEST_SUITE_END();
};
CPPUNIT_TEST_SUITE_REGISTRATION( mystringTest );

avec les macros

int main ()
{
  CppUnit::TestSuite* suite = new CppUnit::TestSuite("mystringTest");
  suite->addTest(new CppUnit::TestCaller<mystringTest>("checkLength",
                &mystringTest::checkLength));
  suite->addTest(new CppUnit::TestCaller<mystringTest>("checkValue",
                &mystringTest::checkLength));

  //client code follows next 
  CppUnit::TextTestRunner runner;
  runner.addTest(suite);

  runner.run();
  return 0;
}

http://www.ibm.com/developerworks/aix/library/au-ctools2_cppunit/

---

Boost Framework De Test Unitaire

#include <boost/test/unit_test.hpp>

using namespace std;

struct CMyFooTestFixture
{
    CMyFooTestFixture() { ... } //SetUp
    ~CMyFooTestFixture() { ... } //TearDown

    void function1_to_test_some_code(CMyFoo& foo) { ... };
    void function2_to_test_some_code(CMyFoo& foo) { ... };
}

BOOST_FIXTURE_TEST_SUITE(MyFooTest, CMyFooTestFixture);

BOOST_AUTO_TEST_CASE(function1_to_test_some_code)
{
    CMyFoo foo;
    function1_to_test_some_code(foo);
}

BOOST_AUTO_TEST_CASE(function1_to_test_some_code2)
{
    CMyFoo foo;
    function1_to_test_some_code(foo);
}

BOOST_AUTO_TEST_SUITE_END();

http://www.beroux.com/english/articles/boost_unit_testing/

Pour la vérification Intégrée, pourrais-je vous suggérer le C++ mise en œuvre de l'AJUSTEMENT (Framework de Test Intégré) - http://fit.c2.com aka CEEFIT (http://ceefit.woldrich.com/?page=Home) (au moment de la rédaction de cet article le ceefit site était down. j'espère qu'il va revenir bientôt). J'ai personnellement utilisé CEEFIT pour exécuter des Tests sur l'héritage de code C++-bases qui interagissent avec la Conception Assistée par Ordinateur plate-forme de l'API (SolidWorks si vous êtes au courant de ça). J'ai la chance de CEEFIT est open source, parce que j'ai eu de l'étendre pour le faire personnalisé choses, comme lire plusieurs tables en entrée (comportement par défaut est de lire un seul tableau pour un test de la classe). Après avoir travaillé avec CEEFIT pour au moins un an maintenant, je suis relativement confiant, j'pouvez exécuter des Tests sur la plupart des systèmes avec cet outil.

Shameless plug - certains de mes billets de blog relatant mon expérience avec CEEFIT avec les téléchargements
http://ossandcad.blogspot.com/2009/07/swx-batch-mode-integrated-tests-with.html
http://ossandcad.blogspot.com/2009/02/writing-ceefit-class-like-regular-c.html

Il y a quelques réserves avec CEEFIT bien - fournir des commentaires par le biais d'un format de tableau n'est pas toujours possible (pas CEEFIT de la faute, c'est par la conception de l'AJUSTEMENT, qui CEEFIT simplement met en œuvre). Le code source n'a pas été mis à jour depuis de nombreuses années, si ma mémoire est bonne (car le site est en panne), depuis l'année 2005, mais depuis sa open source, cela n'a pas causé de nombreux problèmes pour moi dans mon travail).

Nous travaillons dur pour rendre les tests unitaires et TDD faisable en C++. Nous prolongeons Eclipse CDT de le faire. Actuellement, vous pouvez essayer:

http://cute-test.com - notre framework de test unitaire avec Eclipse CDT plug-in

Un de mes étudiants de master est actuellement mise en œuvre de "Mockator", une maquette de l'objet de l'infrastructure qui fonctionne grâce à l'injection de dépendance par l'introduction de paramètres de modèle au lieu de l'obligation au moyen de la succession (comme par exemple avec google maquette). Cela devrait devenir disponible par le biais de notre MIGNON plug-in plus tard cet été.

Une autre équipe d'étudiants a mis en œuvre TDD soutien pour Eclipse CDT, qui va encore être intégrée dans notre mignon plug-in (mais fonctionne aussi sans le joli cadre).

Tout ce qui sera disponible gratuitement.

unittest++