QtTest based test driver for cucumber-cpp.

Implementation based on temporary file.
Unit tests included.
When building QtTest driver C++11 is enabled globally to prevent issue #141.

Author: konserw

CMakeLists.txt

@@ -124,6 +124,10 @@ if(NOT CUKE_DISABLE_QT)
     if(${Qt5Core_FOUND} AND ${Qt5Widgets_FOUND} AND ${Qt5Test_FOUND})
         message(STATUS "Found Qt version: ${Qt5Core_VERSION_STRING}")
         set(QT_LIBRARIES Qt5::Core Qt5::Widgets Qt5::Test)
+	if(NOT Qt5Core_VERSION_STRING VERSION_LESS 5.7 AND (NOT DEFINED CMAKE_CXX_STANDARD OR NOT CMAKE_CXX_STANDARD STREQUAL 98))
+            message(STATUS "C++11 is needed from Qt version 5.7.0, building with c++11 enabled")
+            set(CMAKE_CXX_STANDARD 11)
+        endif()
     else()
         find_package(Qt4 COMPONENTS QtCore QtGui QtTest)
         if(QT4_FOUND)

README.md

@@ -33,7 +33,7 @@ It relies on a few libraries:
   Optional for the GTest driver. By default downloaded and built by CMake.
 * [GMock](http://code.google.com/p/googlemock/) 1.6 or later.
   Optional for the internal test suite. By default downloaded and built by CMake.
-* [Qt 4 or 5](http://qt-project.org/). Optional for the CalcQt example.
+* [Qt 4 or 5](http://qt-project.org/). Optional for the CalcQt example and QtTest driver (only Qt 5).
 
 This header-only library is included in the source code:
 

examples/Calc/CMakeLists.txt

@@ -20,3 +20,8 @@ if(Boost_UNIT_TEST_FRAMEWORK_FOUND)
     add_executable(BoostCalculatorSteps features/step_definitions/BoostCalculatorSteps)
     target_link_libraries(BoostCalculatorSteps Calc ${CUKE_LIBRARIES} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 endif()
+
+if(Qt5TEST_FOUND)
+    add_executable(QtTestCalculatorSteps features/step_definitions/QtTestCalculatorSteps)
+    target_link_libraries(QtTestCalculatorSteps Calc ${QT_LIBRARIES} ${CUKE_LIBRARIES})
+endif()

examples/Calc/features/step_definitions/QtTestCalculatorSteps.cpp

@@ -0,0 +1,4 @@
+#include <QTest>
+// Pretend to be GTest
+#define EXPECT_EQ QCOMPARE 
+#include "CalculatorSteps.cpp"

examples/CalcQt/CMakeLists.txt

@@ -9,12 +9,20 @@ if(QT_LIBRARIES)
     add_executable(calcqt src/CalcQt.cpp)
     target_link_libraries(calcqt libcalcqt ${QT_LIBRARIES})
 
+    if(Qt5TEST_FOUND)
+        add_executable(QtTestCalculatorQtSteps features/step_definitions/QtTestCalculatorQtSteps)
+        set_target_properties(QtTestCalculatorQtSteps PROPERTIES AUTOMOC ON)
+        target_link_libraries(QtTestCalculatorQtSteps PRIVATE libcalcqt ${QT_LIBRARIES} ${CUKE_LIBRARIES})
+    endif()
+
     if(Boost_UNIT_TEST_FRAMEWORK_FOUND)
         add_executable(BoostCalculatorQtSteps features/step_definitions/BoostCalculatorQtSteps)
         target_link_libraries(BoostCalculatorQtSteps libcalcqt ${CUKE_LIBRARIES} ${QT_LIBRARIES} ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
     endif()
+
     if(GTEST_FOUND)
         add_executable(GTestCalculatorQtSteps features/step_definitions/GTestCalculatorQtSteps)
         target_link_libraries(GTestCalculatorQtSteps libcalcqt ${CUKE_LIBRARIES} ${CUKE_GTEST_LIBRARIES} ${QT_LIBRARIES})
     endif()
+
 endif()

examples/CalcQt/features/step_definitions/QtTestCalculatorQtSteps.cpp

@@ -0,0 +1,4 @@
+#include <QTest>
+// Pretend to be GTest
+#define EXPECT_EQ QCOMPARE
+#include "CalculatorQtSteps.cpp"

include/cucumber-cpp/internal/drivers/DriverSelector.hpp

@@ -2,4 +2,6 @@
     #include "GTestDriver.hpp"
 #elif defined(BOOST_TEST_CASE)
     #include "BoostDriver.hpp"
+#elif defined(QTEST_H)
+    #include "QtTestDriver.hpp"
 #endif

include/cucumber-cpp/internal/drivers/QtTestDriver.hpp

@@ -0,0 +1,39 @@
+#ifndef CUKE_QTTESTDRIVER_HPP_
+#define CUKE_QTTESTDRIVER_HPP_
+
+#include "../step/StepManager.hpp"
+#include <QObject>
+
+namespace cucumber {
+namespace internal {
+
+class QtTestStep : public BasicStep{
+    friend class QtTestObject;
+public:
+    QtTestStep(): BasicStep() {}
+
+protected:
+    const InvokeResult invokeStepBody();
+};
+
+#define STEP_INHERITANCE(step_name) ::cucumber::internal::QtTestStep
+
+class QtTestObject: public QObject {
+    Q_OBJECT
+public:
+    QtTestObject(QtTestStep* qtTestStep): step(qtTestStep) {}
+    virtual ~QtTestObject() {}
+
+protected:
+    QtTestStep* step;
+
+private slots:
+    void test() const {
+        step->body();
+    }
+};
+
+}
+}
+
+#endif /* CUKE_QTTESTDRIVER_HPP_ */

src/CMakeLists.txt

@@ -26,6 +26,13 @@ if(Boost_UNIT_TEST_FRAMEWORK_FOUND)
     list(APPEND CUKE_SOURCES drivers/BoostDriver.cpp)
 endif()
 
+if(Qt5TEST_FOUND)
+    qt5_wrap_cpp(MOC_FILE ../include/cucumber-cpp/internal/drivers/QtTestDriver.hpp)
+    list(APPEND CUKE_SOURCES ${MOC_FILE})
+    list(APPEND CUKE_SOURCES drivers/QtTestDriver.cpp)
+    list(APPEND CUKE_DEP_LIBRARIES ${QT_LIBRARIES})
+endif()
+
 if(CMAKE_EXTRA_GENERATOR OR MSVC_IDE)
     message(STATUS "Adding header files to project")
     file(GLOB_RECURSE CUKE_HEADERS "${CUKE_INCLUDE_DIR}/cucumber-cpp/*.hpp")

src/drivers/QtTestDriver.cpp

@@ -0,0 +1,32 @@
+#include "cucumber-cpp/internal/drivers/QtTestDriver.hpp"
+
+#include <QtTest/QtTest>
+#include <QTextStream>
+#include <QTemporaryFile>
+
+namespace cucumber {
+namespace internal {
+
+const InvokeResult QtTestStep::invokeStepBody() {
+    QTemporaryFile file;
+    QString fileName;
+    if(!file.open()) {
+        return InvokeResult::failure("Unable to open temporary file needed for this test");
+    }
+    file.close();
+
+    QtTestObject testObject(this);
+    int returnValue = QTest::qExec(&testObject, QStringList() << "test" << "-o" << file.fileName());
+    if(returnValue == 0)
+        return InvokeResult::success();
+    else
+    {
+        file.open();
+        QTextStream ts(&file);
+        return InvokeResult::failure(ts.readAll().toLocal8Bit());
+    }
+}
+
+}
+}
+

tests/CMakeLists.txt

@@ -48,4 +48,8 @@ if(Boost_UNIT_TEST_FRAMEWORK_FOUND)
     cuke_add_driver_test(integration/drivers/BoostDriverTest ${Boost_UNIT_TEST_FRAMEWORK_LIBRARY})
 endif()
 
+if(Qt5TEST_FOUND)
+    cuke_add_driver_test(integration/drivers/QtTestDriverTest ${QT_LIBRARIES})
+endif()
+
 cuke_add_driver_test(integration/drivers/GenericDriverTest)

tests/integration/drivers/QtTestDriverTest.cpp

@@ -0,0 +1,65 @@
+#include <QtTest>
+#include <cucumber-cpp/autodetect.hpp>
+
+#include "../../utils/DriverTestRunner.hpp"
+
+using namespace cucumber;
+
+THEN(SUCCEED_MATCHER) {
+    ScenarioScope<SomeContext> ctx;
+    QVERIFY(true);
+}
+
+THEN(FAIL_MATCHER) {
+    ScenarioScope<SomeContext> ctx;
+    QVERIFY(false);
+}
+
+THEN(PENDING_MATCHER_1) {
+    pending();
+}
+
+THEN(PENDING_MATCHER_2) {
+    pending(PENDING_DESCRIPTION);
+}
+
+using namespace cucumber::internal;
+
+class QtTestStepDouble : public QtTestStep {
+public:
+    QtTestStepDouble() : QtTestStep() {
+        testRun = false;
+    }
+
+    const InvokeResult invokeStepBody() {
+        return QtTestStep::invokeStepBody();
+    }
+
+    void body() {
+        testRun = true;
+    }
+
+    bool testRun;
+};
+
+class QtTestDriverTest : public DriverTest {
+public:
+    virtual void runAllTests() {
+        stepInvocationRunsStepBody();
+        DriverTest::runAllTests();
+    }
+
+private:
+    void stepInvocationRunsStepBody() {
+        QtTestStepDouble framework;
+        expectFalse("The test body has not been run", framework.testRun);
+        framework.invokeStepBody();
+        expectTrue("The test body has been run", framework.testRun);
+    }
+};
+
+int main() {
+    QtTestDriverTest test;
+    return test.run();
+}
+

travis.sh

@@ -53,6 +53,7 @@ fi
 
 for TEST in \
     build/examples/Calc/GTestCalculatorSteps \
+    build/examples/Calc/QtTestCalculatorSteps \
     build/examples/Calc/BoostCalculatorSteps \
     build/examples/Calc/FuncArgsCalculatorSteps \
 ; do
@@ -66,6 +67,7 @@ done
 
 for TEST in \
     build/examples/CalcQt/GTestCalculatorQtSteps \
+    build/examples/CalcQt/QtTestCalculatorQtSteps \
     build/examples/CalcQt/BoostCalculatorQtSteps \
 ; do
     if [ -f "${TEST}" -a -n "${DISPLAY:-}" ]; then