Tests unitaires et backtrace sous Windows et Linux

La classe de base de la structure arborescente est TestFunctionStruct. Elle définit, entre autres, le nom du test ainsi que plusieurs fonctions virtuelles surchargées par les classes filles :

• unsigned int nbTests() : retourne le nombre de tests dans le sous-arbre, utile pour l'interface graphique ;
• void operator()() : exécute le test ;
• void addTest(QStringList, TestFunctionStruct*) : ajoute un test défini par une liste de sous-chaînes ;
• bool hasLeaves() const {return false;} : indique si le test a des feuilles ;
• std::map<QString, TestFunctionStruct*>& getLeaves() : retourne la carte des nœuds fils – par défaut, cette fonction lève une exception – ;
• std::list<TestFunctionStruct*> getRealTests() : retourne la liste de tous les tests dans les sous-arbres.

La fonction permettant de récupérer les tests dans un sous-arbre est traditionnellement implémentée à l'aide du pattern Visiteur. Pour la simplicité de la bibliothèque, ce pattern n'a pas été utilisé, on retourne simplement une liste, celle-ci pourra être utilisée pour autre chose qu'effectuer les tests.

Cette classe hérite publiquement de TestFunctionStruct, mais dépend d'un paramètre template. Cet argument permet de spécifier une fonction qui sera appelée et exécutée lors de l'appel à operator()(). Si vous préférez utiliser des foncteurs, c'est cette classe que vous devrez modifier/copier.

• Le constructeur : outre l'initialisation de la classe parente avec le nom du test, la création d'une instance de TestSuite entraîne automatiquement son enregistrement dans le registre, le TestManager.
• unsigned int nbTests() : retourne 1, car un test est défini ici.
• void operator()() : exécute la fonction.
• std::list<TestFunctionStruct*> getRealTests() : retourne une liste à un seul élément.

Cette classe est la colle, le lien entre les différents tests.

• Le constructeur : ce constructeur, très simple, initialise la classe mère ainsi que la variable interne nbTests à 0. En effet, au départ, il n'y a aucun test dans ce nœud.
• unsigned int nbTests() : retourne nbTests.
• void operator()() : ne fait rien.
• bool hasLeaves() const {return true;} : retourne true.
• std::map<QString, TestFunctionStruct*>& getLeaves() : retourne la carte des nœuds fils qui stocke les sous-nœuds existants.
• std::list<TestFunctionStruct*> getRealTests() : retourne une liste construite récursivement contenant tous les tests du sous-arbre.
• void addTest(QStringList path, TestFunctionStruct* test) : cette fonction spécifique à TestComposite incrémente le nombre de tests dans l'arbre et ajoute récursivement le test dans le sous-arbre.

Contrairement à l'exemple fourni du pattern Registry, il n'y a pas d'utilité à la recherche directe d'un élément dans le registre, donc cette fonction est inutile ; le test est directement l'élément enregistré dans l'arbre, aucun encapsuleur n'est utilisé, pour simplifier l'arborescence, et l'ajout de tests est fait de manière récursive, pour ajouter en modularité. Enfin, le nom complet du test est enregistré, une fois de plus contrairement à ce qui était proposé dans le pattern Registry, afin d'afficher facilement le nom complet du test.

Une assertion va tester une condition - par exemple une égalité ou une inégalité -. Elle utilisera les méthodes associées aux instances des classes comparées. Lorsque la comparaison échouera, on lancera une exception particulière indiquant le type d'erreur, la fonction où l'erreur est survenue, la ligne… En ce qui concerne ces derniers éléments, on utilisera une macro du préprocesseur, __FILE__, __LINE__ et __FUNCTION__, pour s'occuper du travail. Pour éviter d'avoir à écrire ces macros, on encapsule l'appel à la fonction de test dans une macro.

Lorsqu'on lance plusieurs tests, on peut obtenir une liste des tests à effectuer grâce à getRealTests(). Ensuite, on parcourt cette liste en lançant chaque test et en récupérant toutes les erreurs, celles attendues grâce à notre exception particulière, et les autres auxquelles on ne s'attendrait pas.

Pour l'utiliser, il suffit de compiler avec QCore(d)4.dll.

#include <exception>
#include <fstream>

#include <cstdio>
#include <iostream>
#include <string>
#include "test_register_function.h"
#include "test_functions.h"

#ifdef Q_OS_WIN
#include "windows.h"

static CRITICAL_SECTION outputCriticalSection;
static HANDLE hConsole = INVALID_HANDLE_VALUE;
static WORD consoleAttributes = 0;

static const char *qWinColoredMsg(int prefix, int color, const char *msg)
{
    if (!hConsole)
        return msg;

    WORD attr = consoleAttributes & ~(FOREGROUND_GREEN | FOREGROUND_BLUE
              | FOREGROUND_RED | FOREGROUND_INTENSITY);
    if (prefix)
        attr |= FOREGROUND_INTENSITY;
    if (color == 32)
        attr |= FOREGROUND_GREEN;
    if (color == 31)
        attr |= FOREGROUND_RED | FOREGROUND_INTENSITY;
    if (color == 37)
        attr |= FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
    if (color == 33)
        attr |= FOREGROUND_RED | FOREGROUND_GREEN;
    SetConsoleTextAttribute(hConsole, attr);
    printf(msg);
    SetConsoleTextAttribute(hConsole, consoleAttributes);
    return "";
}

# define COLORED_MSG(prefix, color, msg) qWinColoredMsg(prefix, color, msg)
#else
# define COLORED_MSG(prefix, color, msg) "\033["#prefix";"#color"m" msg "\033[0m"
#endif

void iterateThroughTests(TestFunctionStruct* test)
{
  if(test->hasLeaves())
  {
    std::map<QString, TestFunctionStruct*>& leaves = test->getLeaves();
    for(std::map<QString, TestFunctionStruct*>::iterator it = leaves.begin(); it != leaves.end(); ++it)
    {
      iterateThroughTests(it->second);
    }
  }
  else
  {
    try
    {
      (*test)();
      std::cout << COLORED_MSG(0, 32, "PASS   ") <<  test->functionName.toStdString() << std::endl;
    }
    catch(const Tester::Thrown& failure)
    {
      std::cout << COLORED_MSG(0, 31, "FAIL!  ") <<  test->functionName.toStdString() << std::endl;
      std::cout << "* " << failure.explanation.toStdString() << std::endl;
    }
    catch(const std::exception& exception)
    {
      std::cout << COLORED_MSG(0, 31, "FAIL!  ") <<  test->functionName.toStdString() << std::endl << "  " << exception.what() << std::endl;
    }
    catch(...)
    {
      std::cout << COLORED_MSG(0, 37, "ERROR! ") <<  test->functionName.toStdString() << std::endl << "  Unknown error" << std::endl;
    }
  }
}

int main(int argc, char **argv)
{

  TestManager& manager = TestManager::getInstance();
  iterateThroughTests(manager.getRoot());
  return EXIT_SUCCESS;
}

Ici, il faudra compiler avec test_gui.h et test_gui.cpp, le tout en liant avec QGui(d)4.dll ainsi que QCore(d)4.dll.

#define PACKAGE_STRING "Exemple"

#include <exception>
#include <fstream>

#include <QtGui/QtGui>
#include "testGui.h"

int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    Tester::TestMainWindow mainWin(QString::fromAscii(PACKAGE_STRING));
    mainWin.show();
    return app.exec();
}