Quel cadre de test unitaire devrais-je utiliser pour le Qt? [fermé]

vous ne devez pas créer des applications de tests séparés. Il suffit d'utiliser qExec dans une fonction principale indépendante () similaire à celle-ci:

int main(int argc, char *argv[])
{
    TestClass1 test1;
    QTest::qExec(&test1, argc, argv);

    TestClass2 test2;
    QTest::qExec(&test2, argc, argv);

    // ...

    return 0;
}

ceci exécutera toutes les méthodes d'essai dans chaque classe dans un lot.

votre classe de test .les fichiers h ressembleraient à ceci:

class TestClass1 : public QObject
{
Q_OBJECT

private slots:
    void testMethod1();
    // ...
}

Malheureusement, cette configuration n'est pas vraiment bien décrit dans la documentation de Qt, même si elle semble être très utile pour beaucoup de gens.

pour l'ajouter à la réponse de Joe.

voici un petit en-tête que j'utilise (testrunner.h), contenant une classe utilitaire qui produit une boucle d'événement (qui est, par exemple, nécessaire pour tester les connexions signal-slot et les bases de données) et des classes compatibles QTest" running":

#ifndef TESTRUNNER_H
#define TESTRUNNER_H

#include <QList>
#include <QTimer>
#include <QCoreApplication>
#include <QtTest>

class TestRunner: public QObject
{
    Q_OBJECT

public:
    TestRunner()
        : m_overallResult(0)
    {}

    void addTest(QObject * test) {
        test->setParent(this);
        m_tests.append(test);
    }

    bool runTests() {
        int argc =0;
        char * argv[] = {0};
        QCoreApplication app(argc, argv);
        QTimer::singleShot(0, this, SLOT(run()) );
        app.exec();

        return m_overallResult == 0;
    }
private slots:
    void run() {
        doRunTests();
        QCoreApplication::instance()->quit();
    }
private:
    void doRunTests() {
        foreach (QObject * test, m_tests) {
            m_overallResult|= QTest::qExec(test);
        }
    }

    QList<QObject *> m_tests;
    int m_overallResult;
};

#endif // TESTRUNNER_H

utilisez - le comme ceci:

#include "testrunner.h"
#include "..." // header for your QTest compatible class here

#include <QDebug>

int main() {
    TestRunner testRunner;
    testRunner.addTest(new ...()); //your QTest compatible class here

    qDebug() << "Overall result: " << (testRunner.runTests()?"PASS":"FAIL");

    return 0;
}

j'ai commencé à utiliser Qtttest pour mon application et très, très rapidement j'ai commencé à rencontrer des limites avec elle. Les deux principaux problèmes étaient:

1)mes tests s'exécutent très rapidement - suffisamment rapidement pour que le temps de chargement d'un exécutable, La mise en place d'une Application Q(Core) (si nécessaire) ETC éclipse souvent le temps de fonctionnement des tests eux-mêmes! Relier chaque exécutable prend beaucoup de temps, trop.

La surcharge simplement cessé d'augmenter au fur et à d'autres classes ont été ajoutées, et cela est rapidement devenu un problème - l'un des objectifs des tests unitaires est d'avoir un filet de sécurité qui fonctionne si vite que ce n'est pas un fardeau du tout, et ce n'était pas le cas rapidement. La solution consiste à regrouper plusieurs suites de test en un seul exécutable, et bien que (comme montré ci-dessus) cela soit le plus souvent faisable, il est non supporté et a des limites importantes.

2) pas de support fixe - un briseur de deal pour moi.

ainsi, après un certain temps, je suis passé à Google Test - il s'agit d'un cadre de test de l'Unité beaucoup plus fonctionnel et sophistiqué (en particulier lorsqu'il est utilisé avec Google Mock) et résout 1) et 2), et de plus, vous pouvez encore facilement utiliser les fonctionnalités pratiques de QTestLib telles que QSignalSpy et la simulation D'événements GUI, etc. C'était un peu pénible de changer, mais heureusement le projet n'avait pas avancé trop loin et beaucoup de changements pouvaient être automatisés.

personnellement, je ne serai pas utiliser Qtttest sur Google Test pour les projets futurs-si n'offre pas d'avantages réels que je peux voir, et a des inconvénients importants.

pourquoi ne pas utiliser le cadre d'essais unitaires inclus dans Qt? Un exemple: Qttestlib Tutorial .

Qtttest est surtout utile pour tester les pièces qui nécessitent la boucle d'événement Qt/régulation de signal. Il est conçu de manière à ce que chaque cas de test nécessite un exécutable séparé, de sorte qu'il ne devrait pas entrer en conflit avec un cadre de test existant utilisé pour le reste de l'application.

(Btw, je recommande fortement L'utilisation de QtCore même pour les parties non-GUI des applications. C'est beaucoup plus agréable de travailler avec.)

pour étendre la solution mlvljr et Joe's, nous pouvons même prendre en charge les options Qtttest complètes par classe de test et exécuter tout cela dans un lot plus la journalisation:

usage: 
  help:                                        "TestSuite.exe -help"
  run all test classes (with logging):         "TestSuite.exe"
  print all test classes:                      "TestSuite.exe -classes"
  run one test class with QtTest parameters:   "TestSuite.exe testClass [options] [testfunctions[:testdata]]...

en-tête

#ifndef TESTRUNNER_H
#define TESTRUNNER_H

#include <QList>
#include <QTimer>
#include <QCoreApplication>
#include <QtTest>
#include <QStringBuilder>

/*
Taken from /q/what-unit-testing-framework-should-i-use-for-qt-closed-39162/"Cannot create folder %s", mTestLogFolder);
      }
   }

   void addTest(QObject * test)
   {
      test->setParent(this);
      m_tests.append(test);
   }

   bool runTests(int argc, char * argv[]) 
   {
      QCoreApplication app(argc, argv);
      QTimer::singleShot(0, this, SLOT(run()));
      app.exec();

      return m_overallResult == 0;
   }

   private slots:
   void run() 
   {
      doRunTests();
      QCoreApplication::instance()->quit();
   }

private:
   void doRunTests() 
   {
      // BEWARE: we assume either no command line parameters or evaluate first parameter ourselves
      // usage: 
      //    help:                                        "TestSuite.exe -help"
      //    run all test classes (with logging):         "TestSuite.exe"
      //    print all test classes:                      "TestSuite.exe -classes"
      //    run one test class with QtTest parameters:   "TestSuite.exe testClass [options] [testfunctions[:testdata]]...
      if (QCoreApplication::arguments().size() > 1 && QCoreApplication::arguments()[1] == "-help")
      {
         qDebug() << "Usage:";
         qDebug().noquote() << "run all test classes (with logging):\t\t" << qAppName();
         qDebug().noquote() << "print all test classes:\t\t\t\t" << qAppName() << "-classes";
         qDebug().noquote() << "run one test class with QtTest parameters:\t" << qAppName() << "testClass [options][testfunctions[:testdata]]...";
         qDebug().noquote() << "get more help for running one test class:\t" << qAppName() << "testClass -help";
         exit(0);
      }

      foreach(QObject * test, m_tests)
      {
         QStringList arguments;
         QString testName = test->metaObject()->className();

         if (QCoreApplication::arguments().size() > 1)
         {
            if (QCoreApplication::arguments()[1] == "-classes")
            {
               // only print test classes
               qDebug().noquote() << testName;
               continue;
            }
            else
               if (QCoreApplication::arguments()[1] != testName)
               {
                  continue;
               }
               else
               {
                  arguments = QCoreApplication::arguments();
                  arguments.removeAt(1);
               }
         }
         else
         {
            arguments.append(QCoreApplication::arguments()[0]);
            // log to console
            arguments.append("-o"); arguments.append("-,txt");
            // log to file as TXT
            arguments.append("-o"); arguments.append(mTestLogFolder % "/" % testName % ".log,txt");
            // log to file as XML
            arguments.append("-o"); arguments.append(mTestLogFolder % "/" % testName % ".xml,xunitxml");
         }
         m_overallResult |= QTest::qExec(test, arguments);
      }
   }

   QList<QObject *> m_tests;
   int m_overallResult;
   const QString mTestLogFolder = "testLogs";
};

#endif // TESTRUNNER_H

propre code

#include "testrunner.h"
#include "test1" 
...

#include <QDebug>

int main(int argc, char * argv[]) 
{
    TestRunner testRunner;

    //your QTest compatible class here
    testRunner.addTest(new Test1);
    testRunner.addTest(new Test2);
    ...

    bool pass = testRunner.runTests(argc, argv);
    qDebug() << "Overall result: " << (pass ? "PASS" : "FAIL");

    return pass?0:1;
}

i unité testé nos bibliothèques en utilisant gtest et QSignalSpy . Utilisez QSignalSpy pour capter les signaux. Vous pouvez appeler des fentes directement (comme les méthodes normales) pour les tester.

si vous utilisez Qt, je vous recommande D'utiliser QtTest, parce que is a des facilités pour tester L'UI et est simple à utiliser.

si vous utilisez QtCore, vous pouvez probablement vous passer de STL. Je trouve souvent les classes Qt plus faciles à utiliser que les classes STL.

j'ai juste joué avec ça. Le principal avantage de L'utilisation de Google Test sur QtTest pour nous est que nous faisons tout notre développement D'interface utilisateur dans Visual Studio. Si vous utilisez Visual Studio 2012 et installez le Google test adaptateur vous pouvez obtenir VS de reconnaître les tests et de les inclure dans son explorateur de Test. C'est génial pour les développeurs d'être en mesure d'utiliser comme ils écrivent du code, et parce que Google Test est portable, nous pouvons également ajouter les tests à la fin de notre Linux construire.

j'espère qu'à l'avenir quelqu'un ajoutera du support pour C++ à l'un des outils de test concurrents que C# ont, comme NCrunch , Giles et ContinuousTests .

bien sûr, vous pourriez trouver quelqu'un écrit un autre adaptateur pour VS2012 qui ajoute le support Qtttest à L'Adaptateur de Test dans lequel cas cet avantage disparaît! Si quelqu'un est intéressé par ceci, Il ya un bon billet de blog la Création d'un nouveau Visual studio unité d'adaptateur de test .

pour Visual Studio Test adaptateur prise en charge de l'outil avec le cadre QtTest utilisez cette extension Visual Studio: https://visualstudiogallery.msdn.microsoft.com/cc1fcd27-4e58-4663-951f-fb02d9ff3653