Qt Quick Test

Introduction

Qt Quick Test is a unit test framework for QML applications. Test cases are written as JavaScript functions within a TestCase type:

 import QtQuick 2.3
 import QtTest 1.0

 TestCase {
     name: "MathTests"

     function test_math() {
         compare(2 + 2, 4, "2 + 2 = 4")
     }

     function test_fail() {
         compare(2 + 2, 5, "2 + 2 = 5")
     }
 }

Functions whose names start with test_ are treated as test cases to be executed. See the documentation for the TestCase and SignalSpy types for more information on writing test cases.

Using the Module

QML API

The QML types in Qt Quick Test are available through the QtTest import. To use the types, add the following import statement to your .qml file:

 import QtTest

C++ API

Using the C++ API requires linking against the module library, either directly or through other dependencies. Several build tools have dedicated support for this, including CMake and qmake.

Building with CMake

Use the find_package() command to locate the needed module components in the Qt6 package:

 find_package(Qt6 REQUIRED COMPONENTS QuickTest)
 target_link_libraries(mytarget PRIVATE Qt6::QuickTest)

See also the Build with CMake overview.

Building with qmake

There are two ways to link against the corresponding C++ library. If your test project uses a QML TestCase, you should already have the following line in your project file:

 CONFIG += qmltestcase

This will cause the test to link to the C++ QtQuickTest library.

If you have a C++-only test project, you can add the following line to your project file:

 QT += qmltest

Running Tests

Test cases are launched by a C++ harness that consists of the following code:

 #include <QtQuickTest>
 QUICK_TEST_MAIN(example)

Where "example" is the identifier to use to uniquely identify this set of tests.

Using CMake

Configure your CMakeLists.txt file and build your project using your favorite generator.

 cmake_minimum_required(VERSION 3.2)

 project(tst_example LANGUAGES CXX)

 enable_testing()

 find_package(Qt6 REQUIRED COMPONENTS QuickTest Qml)

 #[[The test harness scans the specified source directory recursively
 for "tst_*.qml" files. By default, it looks in the current directory,
 which is usually where the executable is. This command makes it look
 in the project's source directory instead.]]
 add_definitions(-DQUICK_TEST_SOURCE_DIR="${CMAKE_CURRENT_SOURCE_DIR}")

 qt_standard_project_setup(REQUIRES 6.6)

 add_executable(tst_example tst_example.cpp)

 add_test(NAME tst_example COMMAND tst_example)

 target_link_libraries(tst_example
     PRIVATE
     Qt6::QuickTest
     Qt6::Qml
 )

Using qmake

Add CONFIG += qmltestcase to your project file:

 TEMPLATE = app
 TARGET = tst_example
 CONFIG += warn_on qmltestcase
 SOURCES += tst_example.cpp

If IMPORTPATH is specified in your .pro file, each import path added to IMPORTPATH will be passed as a command-line argument when the test is run using "make check":

 IMPORTPATH += $$PWD/../imports/my_module1 $$PWD/../imports/my_module2

The test harness scans the specified source directory recursively for "tst_*.qml" files. If QUICK_TEST_SOURCE_DIR is not defined, then the current directory will be scanned when the harness is run. Other *.qml files may appear for auxillary QML components that are used by the test.

The -input command-line option can be set at runtime to run test cases from a different directory. This may be needed to run tests on a target device where the compiled-in directory name refers to a host. For example:

 tst_example -input /mnt/SDCard/qmltests

It is also possible to run a single file using the -input option. For example:

 tst_example -input data/test.qml

 tst_example -input <full_path>/test.qml

If your test case needs QML imports, then you can add them as -import options to the test program command-line.

The -functions command-line option will return a list of the current tests functions. It is possible to run a single test function using the name of the test function as an argument. For example:

 tst_example Test_Name::function1

The -help command-line option will return all the options available.

 tst_example -help

Executing C++ Before QML Tests

To execute C++ code before any of the QML tests are run, the QUICK_TEST_MAIN_WITH_SETUP macro can be used. This can be useful for setting context properties on the QML engine, amongst other things.

The macro is identical to QUICK_TEST_MAIN, except that it takes an additional type argument. The test framework will call slots and invokable functions with the following names:

The following example demonstrates how the macro can be used to set context properties on the QML engine:

 // src_qmltest_qquicktest.cpp
 #include <QtQuickTest>
 #include <QQmlEngine>
 #include <QQmlContext>
 #include <QGuiApplication>

 class Setup : public QObject
 {
     Q_OBJECT

 public:
     Setup() {}

 public slots:
     void applicationAvailable()
     {
         // Initialization that only requires the QGuiApplication object to be available
     }

     void qmlEngineAvailable(QQmlEngine *engine)
     {
         // Initialization requiring the QQmlEngine to be constructed
         engine->rootContext()->setContextProperty("myContextProperty", QVariant(true));
     }

     void cleanupTestCase()
     {
         // Implement custom resource cleanup
     }
 };

 QUICK_TEST_MAIN_WITH_SETUP(mytest, Setup)

 #include "src_qmltest_qquicktest.moc"

The .moc include is based on the file name of the .cpp file. For example, in the example above, the .cpp file is named src_qmltest_qquicktest.cpp. If the file was named MyTest.cpp, the include would be:

 #include "MyTest.moc"

Reference

• QML Types
• C++ API

Licenses

Qt Quick Tests is available under commercial licenses from The Qt Company. In addition, it is available under free software licenses. Since Qt 5.4, these free software licenses are GNU Lesser General Public License, version 3, or the GNU General Public License, version 2. See Qt Licensing for further details.