Debian Codegraph @

tests/auto/testlib/selftests/signaldumper/tst_signaldumper.cpp

raw
1 // Copyright (C) 2021 The Qt Company Ltd.
2 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
3
4 #include <QtCore/QCoreApplication>
5 #include <QTest>
6 #include <private/qtestlog_p.h>
7
8 class tst_Signaldumper : public QObject
9 {
10 Q_OBJECT
11
12 void addConnectionTypeData();
13
14 private slots:
15 void noConnections();
16 void oneSlot_data();
17 void oneSlot();
18 void oneSlotOldSyntax_data();
19 void oneSlotOldSyntax();
20 void twoSlots_data();
21 void twoSlots();
22 void twoSlotsOldSyntax_data();
23 void twoSlotsOldSyntax();
24 void signalForwarding_data();
25 void signalForwarding();
26 void signalForwardingOldSyntax_data();
27 void signalForwardingOldSyntax();
28 void slotEmittingSignal_data();
29 void slotEmittingSignal();
30 void slotEmittingSignalOldSyntax_data();
31 void slotEmittingSignalOldSyntax();
32
33 void variousTypes();
34
35 void deletingSender();
36 };
37
38 void tst_Signaldumper::addConnectionTypeData()
39 {
40 QTest::addColumn<Qt::ConnectionType>("connectionType");
41 QTest::newRow("direct") << Qt::ConnectionType::DirectConnection;
42 QTest::newRow("queued") << Qt::ConnectionType::QueuedConnection;
43 }
44
45 /*
46 Simple class to keep the slots and signals separate from the test
47 */
48 class SignalSlotClass : public QObject
49 {
50 Q_OBJECT
51
52 public:
53 SignalSlotClass();
54
55 public slots:
56 void slotWithoutParameters() {}
57 void slotWithParameters(int, char) {}
58 void emitSecondSignal() { emit nestedSignal(); }
59
60 signals:
61 void signalWithoutParameters();
62 void signalWithParameters(int i, char c);
63
64 void nestedSignal();
65 void nestedSignalWithParameters(int i, char c);
66
67 // For the "variousTypes" test
68 void qStringSignal(QString string);
69 void qStringRefSignal(QString &string);
70 void qStringConstRefSignal(const QString &string);
71 void qByteArraySignal(QByteArray byteArray);
72 void qListSignal(QList<int> list);
73 void qVectorSignal(QList<int> vector);
74 void qVectorRefSignal(QList<int> &vector);
75 void qVectorConstRefSignal(const QList<int> &vector);
76 void qVectorConstPointerSignal(const QList<int> *vector);
77 void qVectorPointerConstSignal(QList<int> *const vector);
78 void qVariantSignal(QVariant variant);
79 };
80
81 SignalSlotClass::SignalSlotClass()
82 {
83 // For printing signal argument in "variousTypes" test
84 qRegisterMetaType<QList<int>>();
85 qRegisterMetaType<QList<int>>();
86 }
87
88 void tst_Signaldumper::noConnections()
89 {
90 SignalSlotClass signalSlotOwner;
91
92 emit signalSlotOwner.signalWithoutParameters();
93 emit signalSlotOwner.signalWithParameters(242, 'm');
94 }
95
96 void tst_Signaldumper::oneSlot_data()
97 {
98 addConnectionTypeData();
99 }
100
101 void tst_Signaldumper::oneSlot()
102 {
103 QFETCH(Qt::ConnectionType, connectionType);
104
105 SignalSlotClass signalSlotOwner;
106 // parameterless to parameterless
107 auto connection = connect(&signalSlotOwner, &SignalSlotClass::signalWithoutParameters,
108 &signalSlotOwner, &SignalSlotClass::slotWithoutParameters, connectionType);
109 emit signalSlotOwner.signalWithoutParameters();
110
111 QCoreApplication::processEvents();
112 disconnect(connection);
113
114 // parameters to parameters
115 connection = connect(&signalSlotOwner, &SignalSlotClass::signalWithParameters,
116 &signalSlotOwner, &SignalSlotClass::slotWithParameters, connectionType);
117 emit signalSlotOwner.signalWithParameters(242, 'm');
118
119 QCoreApplication::processEvents();
120 disconnect(connection);
121
122 // parameters to no parameters
123 connection = connect(&signalSlotOwner, &SignalSlotClass::signalWithParameters,
124 &signalSlotOwner, &SignalSlotClass::slotWithoutParameters, connectionType);
125 emit signalSlotOwner.signalWithParameters(242, 'm');
126
127 QCoreApplication::processEvents();
128 disconnect(connection);
129 }
130
131 void tst_Signaldumper::oneSlotOldSyntax_data()
132 {
133 addConnectionTypeData();
134 }
135
136 void tst_Signaldumper::oneSlotOldSyntax()
137 {
138 QFETCH(Qt::ConnectionType, connectionType);
139
140 SignalSlotClass signalSlotOwner;
141 // parameterless to parameterless
142 auto connection = connect(&signalSlotOwner, SIGNAL(signalWithoutParameters()),
143 &signalSlotOwner, SLOT(slotWithoutParameters()), connectionType);
144 emit signalSlotOwner.signalWithoutParameters();
145
146 QCoreApplication::processEvents();
147 disconnect(connection);
148
149 // parameters to parameters
150 connection = connect(&signalSlotOwner, SIGNAL(signalWithParameters(int, char)),
151 &signalSlotOwner, SLOT(slotWithParameters(int, char)), connectionType);
152 emit signalSlotOwner.signalWithParameters(242, 'm');
153
154 QCoreApplication::processEvents();
155 disconnect(connection);
156
157 // parameters to no parameters
158 connection = connect(&signalSlotOwner, SIGNAL(signalWithParameters(int, char)),
159 &signalSlotOwner, SLOT(slotWithoutParameters()), connectionType);
160 emit signalSlotOwner.signalWithParameters(242, 'm');
161
162 QCoreApplication::processEvents();
163 disconnect(connection);
164 }
165
166 void tst_Signaldumper::twoSlots_data()
167 {
168 addConnectionTypeData();
169 }
170
171 void tst_Signaldumper::twoSlots()
172 {
173 QFETCH(Qt::ConnectionType, connectionType);
174
175 // Now, instead of creating two slots or two objects, we will just do the same connection twice.
176 // The same slot will then be invoked twice.
177
178 SignalSlotClass signalSlotOwner;
179 // parameterless to parameterless
180 auto connection = connect(&signalSlotOwner, &SignalSlotClass::signalWithoutParameters,
181 &signalSlotOwner, &SignalSlotClass::slotWithoutParameters, connectionType);
182 auto connection2 = connect(&signalSlotOwner, &SignalSlotClass::signalWithoutParameters,
183 &signalSlotOwner, &SignalSlotClass::slotWithoutParameters, connectionType);
184 emit signalSlotOwner.signalWithoutParameters();
185
186 QCoreApplication::processEvents();
187 disconnect(connection);
188 disconnect(connection2);
189
190 // parameters to parameters
191 connection = connect(&signalSlotOwner, &SignalSlotClass::signalWithParameters,
192 &signalSlotOwner, &SignalSlotClass::slotWithParameters, connectionType);
193 connection2 = connect(&signalSlotOwner, &SignalSlotClass::signalWithParameters,
194 &signalSlotOwner, &SignalSlotClass::slotWithParameters, connectionType);
195 emit signalSlotOwner.signalWithParameters(242, 'm');
196
197 QCoreApplication::processEvents();
198 disconnect(connection);
199 disconnect(connection2);
200
201 // parameters to no parameters
202 connection = connect(&signalSlotOwner, &SignalSlotClass::signalWithParameters,
203 &signalSlotOwner, &SignalSlotClass::slotWithoutParameters, connectionType);
204 connection2 = connect(&signalSlotOwner, &SignalSlotClass::signalWithParameters,
205 &signalSlotOwner, &SignalSlotClass::slotWithoutParameters, connectionType);
206 emit signalSlotOwner.signalWithParameters(242, 'm');
207
208 QCoreApplication::processEvents();
209 disconnect(connection);
210 disconnect(connection2);
211 }
212
213 void tst_Signaldumper::twoSlotsOldSyntax_data()
214 {
215 addConnectionTypeData();
216 }
217
218 void tst_Signaldumper::twoSlotsOldSyntax()
219 {
220 QFETCH(Qt::ConnectionType, connectionType);
221
222 // Now, instead of creating two slots or two objects, we will just do the same connection twice.
223 // The same slot will then be invoked twice.
224
225 SignalSlotClass signalSlotOwner;
226 // parameterless to parameterless
227 auto connection = connect(&signalSlotOwner, SIGNAL(signalWithoutParameters()),
228 &signalSlotOwner, SLOT(slotWithoutParameters()), connectionType);
229 auto connection2 = connect(&signalSlotOwner, SIGNAL(signalWithoutParameters()),
230 &signalSlotOwner, SLOT(slotWithoutParameters()), connectionType);
231 emit signalSlotOwner.signalWithoutParameters();
232
233 QCoreApplication::processEvents();
234 disconnect(connection);
235 disconnect(connection2);
236
237 // parameters to parameters
238 connection = connect(&signalSlotOwner, SIGNAL(signalWithParameters(int, char)),
239 &signalSlotOwner, SLOT(slotWithParameters(int, char)), connectionType);
240 connection2 = connect(&signalSlotOwner, SIGNAL(signalWithParameters(int, char)),
241 &signalSlotOwner, SLOT(slotWithParameters(int, char)), connectionType);
242 emit signalSlotOwner.signalWithParameters(242, 'm');
243
244 QCoreApplication::processEvents();
245 disconnect(connection);
246 disconnect(connection2);
247
248 // parameters to no parameters
249 connection = connect(&signalSlotOwner, SIGNAL(signalWithParameters(int, char)),
250 &signalSlotOwner, SLOT(slotWithoutParameters()), connectionType);
251 connection2 = connect(&signalSlotOwner, SIGNAL(signalWithParameters(int, char)),
252 &signalSlotOwner, SLOT(slotWithoutParameters()), connectionType);
253 emit signalSlotOwner.signalWithParameters(242, 'm');
254
255 QCoreApplication::processEvents();
256 disconnect(connection);
257 disconnect(connection2);
258 }
259
260 void tst_Signaldumper::signalForwarding_data()
261 {
262 addConnectionTypeData();
263 }
264
265 void tst_Signaldumper::signalForwarding()
266 {
267 QFETCH(Qt::ConnectionType, connectionType);
268
269 SignalSlotClass signalSlotOwner;
270
271 // parameterless signal to parameterless signal
272 auto connection = connect(&signalSlotOwner, &SignalSlotClass::signalWithoutParameters,
273 &signalSlotOwner, &SignalSlotClass::nestedSignal, connectionType);
274 emit signalSlotOwner.signalWithoutParameters();
275
276 QCoreApplication::processEvents();
277 disconnect(connection);
278
279 // parameter(full) signal to parameter(full) signal
280 connection = connect(&signalSlotOwner, &SignalSlotClass::signalWithParameters,
281 &signalSlotOwner, &SignalSlotClass::nestedSignalWithParameters, connectionType);
282 emit signalSlotOwner.signalWithParameters(242, 'm');
283
284 QCoreApplication::processEvents();
285 disconnect(connection);
286
287 // parameter(full) signal to parameterless signal
288 connection = connect(&signalSlotOwner, &SignalSlotClass::signalWithParameters,
289 &signalSlotOwner, &SignalSlotClass::nestedSignal, connectionType);
290 emit signalSlotOwner.signalWithParameters(242, 'm');
291
292 QCoreApplication::processEvents();
293 disconnect(connection);
294 }
295
296 void tst_Signaldumper::signalForwardingOldSyntax_data()
297 {
298 addConnectionTypeData();
299 }
300
301 void tst_Signaldumper::signalForwardingOldSyntax()
302 {
303 QFETCH(Qt::ConnectionType, connectionType);
304
305 SignalSlotClass signalSlotOwner;
306
307 // parameterless signal to parameterless signal
308 auto connection = connect(&signalSlotOwner, SIGNAL(signalWithoutParameters()),
309 &signalSlotOwner, SIGNAL(nestedSignal()), connectionType);
310 emit signalSlotOwner.signalWithoutParameters();
311
312 QCoreApplication::processEvents();
313 disconnect(connection);
314
315 // parameter(full) signal to parameter(full) signal
316 connection = connect(&signalSlotOwner, SIGNAL(signalWithParameters(int, char)),
317 &signalSlotOwner, SIGNAL(nestedSignalWithParameters(int, char)), connectionType);
318 emit signalSlotOwner.signalWithParameters(242, 'm');
319
320 QCoreApplication::processEvents();
321 disconnect(connection);
322
323 // parameter(full) signal to parameterless signal
324 connection = connect(&signalSlotOwner, SIGNAL(signalWithParameters(int, char)),
325 &signalSlotOwner, SIGNAL(nestedSignal()), connectionType);
326 emit signalSlotOwner.signalWithParameters(242, 'm');
327
328 QCoreApplication::processEvents();
329 disconnect(connection);
330 }
331
332 void tst_Signaldumper::slotEmittingSignal_data()
333 {
334 addConnectionTypeData();
335 }
336
337 void tst_Signaldumper::slotEmittingSignal()
338 {
339 QFETCH(Qt::ConnectionType, connectionType);
340
341 SignalSlotClass signalSlotOwner;
342
343 auto connection = connect(&signalSlotOwner, &SignalSlotClass::signalWithoutParameters,
344 &signalSlotOwner, &SignalSlotClass::emitSecondSignal, connectionType);
345 emit signalSlotOwner.signalWithoutParameters();
346 QCoreApplication::processEvents();
347 disconnect(connection);
348 }
349
350 void tst_Signaldumper::slotEmittingSignalOldSyntax_data()
351 {
352 addConnectionTypeData();
353 }
354
355 void tst_Signaldumper::slotEmittingSignalOldSyntax()
356 {
357 QFETCH(Qt::ConnectionType, connectionType);
358
359 SignalSlotClass signalSlotOwner;
360
361 auto connection = connect(&signalSlotOwner, SIGNAL(signalWithoutParameters()),
362 &signalSlotOwner, SLOT(emitSecondSignal()), connectionType);
363 emit signalSlotOwner.signalWithoutParameters();
364 QCoreApplication::processEvents();
365 disconnect(connection);
366 }
367
368 void tst_Signaldumper::variousTypes()
369 {
370 SignalSlotClass signalSlotOwner;
371 QString string = QString::fromLatin1("Test string");
372 emit signalSlotOwner.qStringSignal(string);
373 emit signalSlotOwner.qStringRefSignal(string);
374 emit signalSlotOwner.qStringConstRefSignal(string);
375 emit signalSlotOwner.qByteArraySignal(QByteArray("Test bytearray"));
376
377 QList<int> list{1, 2, 3, 242};
378 emit signalSlotOwner.qListSignal(list);
379
380 QList<int> vector { 1, 2, 3, 242 };
381 emit signalSlotOwner.qVectorSignal(vector);
382 emit signalSlotOwner.qVectorRefSignal(vector);
383 emit signalSlotOwner.qVectorConstRefSignal(vector);
384 emit signalSlotOwner.qVectorConstPointerSignal(&vector);
385 emit signalSlotOwner.qVectorPointerConstSignal(&vector);
386
387 QVariant variant = 24;
388 emit signalSlotOwner.qVariantSignal(variant);
389 variant = QVariant(string);
390 emit signalSlotOwner.qVariantSignal(variant);
391 }
392
393 void tst_Signaldumper::deletingSender()
394 {
395 SignalSlotClass *signalSlotOwner = new SignalSlotClass();
396 connect(signalSlotOwner, &SignalSlotClass::signalWithoutParameters, [signalSlotOwner]() {
397 delete signalSlotOwner;
398 });
399 emit signalSlotOwner->signalWithoutParameters();
400 }
401
402 QTEST_MAIN_WRAPPER(tst_Signaldumper,
403 std::vector<const char*> args(argv, argv + argc);
404 args.push_back("-vs");
405 argc = int(args.size());
406 argv = const_cast<char**>(&args[0]);
407 QTEST_MAIN_SETUP())
408
409 #include "tst_signaldumper.moc"