Que Quadro de testes unitários devo usar para o Qt? [fechado]

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

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

    // ...

    return 0;
}

Isto irá executar todos os métodos de ensaio em cada classe de um lote.

A sua classe de teste .os ficheiros h seriam os seguintes:

class TestClass1 : public QObject
{
Q_OBJECT

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

Aqui está um pequeno cabeçalho que eu uso (testrunner.h), contendo uma classe de utilidade que gera um ciclo de eventos (que é, por exemplo, necessário para testar conexões de sinal em fila de espera e bases de dados) e classes" executando " QTest-compatíveis:

#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

Usa-o assim:

#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;
}

Comecei a usar o QtTest para o meu aplicativo e muito, muito rapidamente comecei a ter limitações com ele. Os dois principais problemas foram:

1) Os meus testes são muito rápidos-suficientemente rápidos para que a sobrecarga de carregar um executável, configurar uma aplicação Q(Core) (se necessário), etc, diminua frequentemente o tempo de execução dos próprios testes! Ligar cada executável leva muito tempo também.

Pessoalmente, não vou usar o QtTest sobre o teste do Google para projectos futuros-se não oferecer vantagens reais que eu possa ver, e tem desvantagens importantes.

Porque não usar a estrutura de testes de unidade incluída no Qt? Um exemplo: Qttestlib Tutorial .

O QtTest é, na sua maioria, útil para testar as partes que necessitam do 'Qt event loop' / 'signal dispatching'. Ele é projetado de uma forma que cada caso de teste requer um executável separado, então ele não deve entrar em conflito com qualquer estrutura de teste existente usado para o resto da aplicação.

(Btw, eu recomendo muito o uso de QtCore mesmo para partes não-GUI das aplicações. É muito melhor trabalhar com ele.)

Para extender a solução do mlvljr e do Joe, podemos até mesmo suportar opções completas do QtTest por uma classe de teste e ainda executar tudo num lote mais registo:

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]]...

Cabeçalho

#ifndef TESTRUNNER_H
#define TESTRUNNER_H

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

/*
Taken from https://stackoverflow.com/questions/1524390/what-unit-testing-framework-should-i-use-for-qt
BEWARE: there are some concerns doing so, see  https://bugreports.qt.io/browse/QTBUG-23067
*/
class TestRunner : public QObject
{
   Q_OBJECT

public:
   TestRunner() : m_overallResult(0) 
   {
      QDir dir;
      if (!dir.exists(mTestLogFolder))
      {
         if (!dir.mkdir(mTestLogFolder))
            qFatal("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

Código próprio

#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;
}

A unidade I testou as nossas bibliotecas usando o gtest e O QSignalSpy . Use o QSignalSpy para apanhar sinais. Você pode chamar slots diretamente (como métodos normais) para testá-los.

Se está a usar o Qt, eu recomendaria o uso do QtTest, porque o is tem instalações para testar a IU e é simples de usar.

Se usar o QtCore, pode passar sem STL. Eu frequentemente acho as classes Qt mais fáceis de usar do que as contrapartes STL.

Eu sou esperando no futuro que alguém adicione suporte para C++ a uma das ferramentas de teste simultâneas que o C# tem, como NCrunch, Giles e continuam a investigar .

Claro, você pode encontrar alguém que escreve outro adaptador para VS2012 que adiciona suporte QtTest para testar o adaptador, caso em que esta vantagem desaparece! Se alguém estiver interessado nisto, há um bom post no blog a criar um novo adaptador de teste Visual studio unit.

Para Suporte de Ferramenta de adaptador Visual Studio com o qttest framework use esta extensão Visual Studio: https://visualstudiogallery.msdn.microsoft.com/cc1fcd27-4e58-4663-951f-fb02d9ff3653