Comment structurer le projet tout en testant l'application Qt par QTestLib

j'ai utiliser cette méthode: http://xilexio.org/?p=125

à savoir, place a test config dans le seul et unique .pro fichier qui construit tout. Hiérarchie des fichiers:

myproject.pro
src/
    Example1.cpp
    Example2.cpp
    Example1.h
    Example2.h
test/
    ExampleTest.cpp
    ExampleTest.h

myproject.pro fichier:

QT += #needed modules

CONFIG += qt c++11

HEADERS += \
    src/Example1.h \
    src/Example2.h

SOURCES += \
    src/Example1.h \
    src/Example2.h

test{
    message(Configuring test build...)

    TEMPLATE = app
    TARGET = myapptests

    QT += testlib

    HEADERS += \
        test/ExampleTest.h

    SOURCES += \
        test/ExampleTest.cpp
}
else{
    TEMPLATE = lib
    TARGET = myapp

    CONFIG += plugin

    TARGET = $$qtLibraryTarget($$TARGET)
}

dans mon exemple, je suis en train de construire une bibliothèque de plugin, mais la méthode devrait aussi fonctionner pour une application. Dans le cas d'une application, il est probable que SOURCES -= src/main.cpp est nécessaire sous le else clause, les bibliothèques plugin ne l'ont pas. Si ce n'est pas fait, le main() de l'application en découdront avec l' main() des essais unitaires.

ExampleTest.cpp se présente comme suit:

#include "ExampleTest.h"

void ExampleTest::exampleTest(){
    //Do the tests
}

QTEST_MAIN(ExampleTest)

ExampleTest.h se présente comme suit:

#include <QtTest/QtTest>

class ExampleTest : public QObject {
Q_OBJECT

private slots:
    void exampleTest();
};

pour compiler les tests du projet, dans un répertoire distinct de celui de la compilation régulière, Lancez:

qmake path/to/myproject.pro "CONFIG += test"

j'aime sur les autres réponses, mais je voudrais aussi donner de la rétroaction comment nous le faisons à l'entreprise pour laquelle je travaille actuellement pour:

1. Créer un subdirs projet (ce sera le projet de haut niveau qui gérera tout, y compris votre projet de bibliothèque ou ce que vous voulez tester)

   +-----MyProject (top-level subdirs)
   

2. ajouter vos projets de bibliothèque comme sous-projet

   +-----MyProject (top-level subdirs)
             |
             +-----Library (library project, UI project etc.)
   

3. Ajouter un autre subdirs projets (pour l' les tests)

   +-----MyProject (top-level subdirs)
             |
             +-----Library (library project, UI project etc.)
             |
             +-----Tests (subdirs for tests)
   

4. Créer un QUnitTest projet de l'ajouter à l'essai subdirs projet

   +-----MyProject (subdirs)
             |
             +-----Library (library project, UI project etc.)
             |
             +-----Tests (subdirs for tests)
                     |
                     +----- TestA (QUnitTest project for testing feature A)
   

5. ajouter autant de tests que vous le souhaitez

            ...
             |
             +-----Tests (subdirs for test)
                     |
                     +----- TestA (QUnitTest project for testing feature A)
                     |
                     +----- TestB (QUnitTest project for testing feature B)
                     |
                     +----- TestC (QUnitTest project for testing feature C)
                     |
                    ...
                     |
                     +----- TestZ (QUnitTest project for testing feature Z)
   

si vous avez besoin de grouper les tests dans des groupes, vous pouvez aussi utiliser subdirs pour le faire. subdirs assure également la création de réel répertoires dans votre système de fichiers. Si vous voulez éviter de trop subdirs ing vous pouvez grouper les tests dans des dossiers que vous vous avez créé vous-même dans votre système de fichiers à l'intérieur du Tests dossier du projet.

A côté de cela je recommande aussi d'ajouter un subdirsmodèle de projets.

+-----MyProject (subdirs)
          |
          +-----Library (library project, UI project etc.)
          |
          +-----Tests (subdirs for tests)
          |           |
          |          ...
          |
          +-----Templates (subdirs for template projects
                      |
                      +----- TemplateA (template project for feature A)
                      |
                      +----- TemplateB (template project for feature B)
                      |
                      +----- TemplateAB (template project for feature A and B together)
                      |
                     ...
                      |
                      +----- TemplateZ (template project for feature Z)

ceci est bien sûr basé sur la fonctionnalité de votre bibliothèque. Avec les projets de gabarits je veux dire les widgets personnalisés etc. ce lien contre votre bibliothèque et exposer sélectivement (ou tout) de sa fonctionnalité dans la façon dont il est censé apparaître à l'utilisateur. Par exemple, si vous avez une bibliothèque cela gère divers appareils photo vous pouvez créer un projet de modèle pour chaque appareil photo permettant ainsi aux utilisateurs de votre bibliothèque de copier-coller le projet de modèle spécifique et de l'étendre ou au moins voir comment l'intégration de votre bibliothèque est censée se produire en général. Cela permet de réduire la documentation et en même temps de donner de beaux exemples autonomes qui devraient réduire le temps de développement qui est autrement consacré à comprendre comment l'intégration et l'utilisation de la les ouvrages de bibliothèque (vous pouvez dire que c'est une sorte d'ensemble de Hello World projects :)). Enfin, vous pouvez esquisser des solutions pour différents cas d'utilisation.

J'utilise Qt Creator par CMake au lieu de qmake pour construire mon projet Qt.

Fondamentalement, je dois dossiers:

src
tests

chaque test est un programme en lui-même testant une classe. L'application à tester est compilé comme une bibliothèque.. Vous compilez toutes vos sources dans le dossier src, comme une bibliothèque.

// ClassTest.cpp
#include "ClassTest.h"
#include "Class2Test.h" // Class of the app

#include <QtTest/QtTest>

ClassTest::ClassTest( QObject* parent )
    : QObject(parent)
{ 
}

QTEST_MAIN( ClassTest )
#include "ClassTest.moc"

il suffit de lier votre lib à votre exécutable de test.

Exemple:

dans le dossier src CMakeLists.txt exemple

add_library( MyAPP
    SHARED
    Class2Test.cpp
)
target_link_libraries( MyAPP
    ${QT_LIBRARIES}
)

dans le dossier tests CMakeLists.exemple txt, pour chaque test.

qt4_automoc( ${test_src} )
add_executable( ${test_name} ${test_src} )
target_link_libraries( ${test_name}
    MyAPP
    ${QT_LIBRARIES}
    ${QT_QTTEST_LIBRARY}
)

Il est toujours dans le même projet, mais vous pouvez ajouter un indicateur pour permettre à l'utilisateur de compiler le test ou non. Il est propre, car l'application reste intacte et il permet de tester chaque classe de votre application.