1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
// Copyright (C) 2023 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GFDL-1.3-no-invariants-only
/*!
\page plugin-tests.html
\title Adding Tests
There are two main ways of testing your plugin code:
\list
\li \l{Plugin Tests}
\li \l{Auto Tests}
\endlist
Both have their specific use cases and setup, which is described in the
following sections.
\section1 Setting up CMake
Before adding tests, prepare your build files. They need to look for the
QtTest dependency and have a CMake option for building your plugin with
tests:
\snippet exampleplugin/CMakeLists.txt 5
\section1 Plugin Tests
Plugin tests are deeply integrated into your plugin and its
interaction with \QC. To add a test for something that requires
the infrastructure of \QC or your plugin to be set up, write a plugin
test.
Plugin tests are executed by starting \QC with the \c{-test <pluginname>}
command line argument. \QC then fully loads your plugin and all the plugins
that it depends on, going through the normal \l{Plugin Life Cycle}. After
your plugin and all dependencies are fully initialized, your tests are
executed. Afterwards, \QC automatically closes. Therefore, your plugin
tests have access to all exported functionality of all \QC plugins that
your plugin depends on, like \c{Core::ICore}. Use QtTest's normal test
macros, like \c{QVERIFY} or \c{QCOMPARE} to report your test's success or
failure.
To add plugin tests, add a QObject based class with private slots for your
tests, and register it with \l{ExtensionSystem::IPlugin::addTest()} in your
plugin's \l{ExtensionSystem::IPlugin::initialized()} method. Guard all test
related code with a check for \c{WITH_TESTS}, to avoid shipping a binary
release of your plugin with test functions.
Include QtTest:
\snippet exampleplugin/example.cpp test include
Then implement the test functions:
\snippet exampleplugin/example.cpp plugin tests
Register your test in ExtensionSystem::IPlugin::initialize():
\snippet exampleplugin/example.cpp register tests
If you declared the test object in the source file, like in this example,
also include the \c{.moc} file that is required for Qt's meta object
compiler:
\snippet exampleplugin/example.cpp include moc
\section1 Auto Tests
To add a test that does not depend on a running \QC infrastructure, use an
auto test that lives independent of your plugin interface. Parsers are a
common example, but you can test many things in this way if they have been
written in a modular way.
Even though your test does not live in your plugin interface,
like with plugin tests, you can still link the test to libraries and also
your plugin library itself, to avoid code duplication or duplicate
compilation of code.
In principle you can use any auto test framework,
but QtTest is a simple one that integrates well with Qt, and is also used
for the \l{plugin tests}{Plugin Tests}.
To add your test, add the test's C++ file, and use \c{add_qtc_test} in your
CMake file to add the test target. If your test uses your plugin library,
add it as a dependency with \c{DEPENDS}.
In the following example, the plugin exports a function \c{addOne}:
\quotefile exampleplugin/examplefunctions.h
And implements it in a source file:
\snippet exampleplugin/example.cpp exported function
The test is linked against the plugin library target with \c{DEPENDS}:
\snippet exampleplugin/CMakeLists.txt 6
The QtTest based test then includes the header from the plugin and
tests the function:
\quotefile exampleplugin/tst_mytest.cpp
*/
|
