Debian Codegraph @

tests/auto/qserialport/tst_qserialport.cpp

raw
1 // Copyright (C) 2014 Denis Shienkov <[email protected]>
2 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
3
4 #include <QtTest/QtTest>
5 #include <QtTest/private/qpropertytesthelper_p.h>
6 #include <QtSerialPort/QSerialPort>
7 #include <QtSerialPort/QSerialPortInfo>
8
9 #include <QThread>
10
11 #ifdef Q_OS_UNIX
12 #include <private/qcore_unix_p.h>
13 #include <termios.h>
14 #elif defined(Q_OS_WIN)
15 #include <QtCore/qt_windows.h>
16 #endif
17
18 #ifdef Q_OS_QNX
19 # ifdef open
20 # undef open
21 # endif
22 #endif
23
24 Q_DECLARE_METATYPE(QSerialPort::SerialPortError);
25 Q_DECLARE_METATYPE(QSerialPort::BaudRate);
26 Q_DECLARE_METATYPE(QSerialPort::DataBits);
27 Q_DECLARE_METATYPE(QSerialPort::Parity);
28 Q_DECLARE_METATYPE(QSerialPort::StopBits);
29 Q_DECLARE_METATYPE(QSerialPort::FlowControl);
30 Q_DECLARE_METATYPE(QIODevice::OpenMode);
31 Q_DECLARE_METATYPE(QIODevice::OpenModeFlag);
32 Q_DECLARE_METATYPE(Qt::ConnectionType);
33
34 class tst_QSerialPort : public QObject
35 {
36 Q_OBJECT
37 public:
38 explicit tst_QSerialPort();
39
40 static void enterLoop(int secs)
41 {
42 ++loopLevel;
43 QTestEventLoop::instance().enterLoop(secs);
44 --loopLevel;
45 }
46
47 static void enterLoopMsecs(int msecs)
48 {
49 ++loopLevel;
50 QTestEventLoop::instance().enterLoopMSecs(msecs);
51 --loopLevel;
52 }
53
54 static void exitLoop()
55 {
56 if (loopLevel > 0)
57 QTestEventLoop::instance().exitLoop();
58 }
59
60 static bool timeout()
61 {
62 return QTestEventLoop::instance().timeout();
63 }
64
65 private slots:
66 void initTestCase();
67
68 void defaultConstruct();
69 void constructByName();
70 void constructByInfo();
71
72 void openExisting_data();
73 void openExisting();
74 void openNotExisting_data();
75 void openNotExisting();
76
77 void baudRate_data();
78 void baudRate();
79 void dataBits_data();
80 void dataBits();
81 void parity_data();
82 void parity();
83 void stopBits_data();
84 void stopBits();
85 void flowControl_data();
86 void flowControl();
87
88 void rts();
89 void dtr();
90 void independenceRtsAndDtr();
91
92 void flush();
93 void doubleFlush();
94
95 void waitForBytesWritten();
96
97 void waitForReadyReadWithTimeout();
98 void waitForReadyReadWithOneByte();
99 void waitForReadyReadWithAlphabet();
100
101 void twoStageSynchronousLoopback();
102
103 void synchronousReadWrite();
104
105 void asynchronousWriteByBytesWritten_data();
106 void asynchronousWriteByBytesWritten();
107
108 void asynchronousWriteByTimer_data();
109 void asynchronousWriteByTimer();
110
111 void asyncReadWithLimitedReadBufferSize();
112
113 void readBufferOverflow();
114 void readAfterInputClear();
115 void synchronousReadWriteAfterAsynchronousReadWrite();
116
117 void controlBreak();
118
119 void clearAfterOpen();
120
121 void readWriteWithDifferentBaudRate_data();
122 void readWriteWithDifferentBaudRate();
123
124 void readWriteWithMarkSpaceParity_data();
125 void readWriteWithMarkSpaceParity();
126
127 void bindingsAndProperties();
128
129 void restoreSettingsOnClose();
130
131 void readyReadNotRecursive();
132
133 void writeBufferSizeLimit_data();
134 void writeBufferSizeLimit();
135
136 protected slots:
137 void handleBytesWrittenAndExitLoopSlot(qint64 bytesWritten);
138 void handleBytesWrittenAndExitLoopSlot2(qint64 bytesWritten);
139
140 private:
141 QString m_senderPortName;
142 QString m_receiverPortName;
143 QStringList m_availablePortNames;
144
145 static int loopLevel;
146 static const QByteArray alphabetArray;
147 static const QByteArray newlineArray;
148 };
149
150 int tst_QSerialPort::loopLevel = 0;
151
152 const QByteArray tst_QSerialPort::alphabetArray("ABCDEFGHIJKLMNOPQRSTUVWXUZ");
153 const QByteArray tst_QSerialPort::newlineArray("\n\r");
154
155 tst_QSerialPort::tst_QSerialPort()
156 {
157 qRegisterMetaType<QSerialPort::SerialPortError>("QSerialPort::SerialPortError");
158 }
159
160 void tst_QSerialPort::initTestCase()
161 {
162 m_senderPortName = QString::fromLocal8Bit(qgetenv("QTEST_SERIALPORT_SENDER"));
163 m_receiverPortName = QString::fromLocal8Bit(qgetenv("QTEST_SERIALPORT_RECEIVER"));
164 if (m_senderPortName.isEmpty() || m_receiverPortName.isEmpty()) {
165 static const char message[] =
166 "Test doesn't work because the names of serial ports aren't found in env.\n"
167 "Please set environment variables:\n"
168 " QTEST_SERIALPORT_SENDER to name of output serial port\n"
169 " QTEST_SERIALPORT_RECEIVER to name of input serial port\n"
170 "Specify short names of port"
171 #if defined(Q_OS_UNIX)
172 ", like: ttyS0\n";
173 #elif defined(Q_OS_WIN32)
174 ", like: COM1\n";
175 #else
176 "\n";
177 #endif
178
179 QSKIP(message);
180 } else {
181 m_availablePortNames << m_senderPortName << m_receiverPortName;
182 }
183 }
184
185 void tst_QSerialPort::defaultConstruct()
186 {
187 QSerialPort serialPort;
188
189 QCOMPARE(serialPort.error(), QSerialPort::NoError);
190 QVERIFY(!serialPort.errorString().isEmpty());
191
192 // properties
193 const qint32 defaultBaudRate = static_cast<qint32>(QSerialPort::Baud9600);
194 QCOMPARE(serialPort.baudRate(), defaultBaudRate);
195 QCOMPARE(serialPort.baudRate(QSerialPort::Input), defaultBaudRate);
196 QCOMPARE(serialPort.baudRate(QSerialPort::Output), defaultBaudRate);
197 QCOMPARE(serialPort.dataBits(), QSerialPort::Data8);
198 QCOMPARE(serialPort.parity(), QSerialPort::NoParity);
199 QCOMPARE(serialPort.stopBits(), QSerialPort::OneStop);
200 QCOMPARE(serialPort.flowControl(), QSerialPort::NoFlowControl);
201
202 QCOMPARE(serialPort.pinoutSignals(), QSerialPort::NoSignal);
203 QCOMPARE(serialPort.isRequestToSend(), false);
204 QCOMPARE(serialPort.isDataTerminalReady(), false);
205 QCOMPARE(serialPort.settingsRestoredOnClose(), true);
206
207 // QIODevice
208 QCOMPARE(serialPort.openMode(), QIODevice::NotOpen);
209 QVERIFY(!serialPort.isOpen());
210 QVERIFY(!serialPort.isReadable());
211 QVERIFY(!serialPort.isWritable());
212 QVERIFY(serialPort.isSequential());
213 QCOMPARE(serialPort.canReadLine(), false);
214 QCOMPARE(serialPort.pos(), qlonglong(0));
215 QCOMPARE(serialPort.size(), qlonglong(0));
216 QVERIFY(serialPort.atEnd());
217 QCOMPARE(serialPort.bytesAvailable(), qlonglong(0));
218 QCOMPARE(serialPort.bytesToWrite(), qlonglong(0));
219
220 char c;
221 QCOMPARE(serialPort.read(&c, 1), qlonglong(-1));
222 QCOMPARE(serialPort.write(&c, 1), qlonglong(-1));
223 }
224
225 void tst_QSerialPort::constructByName()
226 {
227 QSerialPort serialPort(m_senderPortName);
228 QCOMPARE(serialPort.portName(), m_senderPortName);
229 serialPort.setPortName(m_receiverPortName);
230 QCOMPARE(serialPort.portName(), m_receiverPortName);
231 }
232
233 void tst_QSerialPort::constructByInfo()
234 {
235 QSerialPortInfo senderPortInfo(m_senderPortName);
236 QSerialPortInfo receiverPortInfo(m_receiverPortName);
237
238 #if defined(Q_OS_UNIX)
239 if (senderPortInfo.isNull() || receiverPortInfo.isNull()) {
240 static const char message[] =
241 "Test doesn't work because the specified serial ports aren't"
242 " found in system and can't be constructed by QSerialPortInfo.\n";
243 QSKIP(message);
244 }
245 #endif
246
247 QSerialPort serialPort(senderPortInfo);
248 QCOMPARE(serialPort.portName(), m_senderPortName);
249 serialPort.setPort(receiverPortInfo);
250 QCOMPARE(serialPort.portName(), m_receiverPortName);
251 }
252
253 void tst_QSerialPort::openExisting_data()
254 {
255 QTest::addColumn<int>("openMode");
256 QTest::addColumn<bool>("openResult");
257 QTest::addColumn<QSerialPort::SerialPortError>("errorCode");
258
259 QTest::newRow("NotOpen") << int(QIODevice::NotOpen) << false << QSerialPort::UnsupportedOperationError;
260 QTest::newRow("ReadOnly") << int(QIODevice::ReadOnly) << true << QSerialPort::NoError;
261 QTest::newRow("WriteOnly") << int(QIODevice::WriteOnly) << true << QSerialPort::NoError;
262 QTest::newRow("ReadWrite") << int(QIODevice::ReadWrite) << true << QSerialPort::NoError;
263 QTest::newRow("Append") << int(QIODevice::Append) << false << QSerialPort::UnsupportedOperationError;
264 QTest::newRow("Truncate") << int(QIODevice::Truncate) << false << QSerialPort::UnsupportedOperationError;
265 QTest::newRow("Text") << int(QIODevice::Text) << false << QSerialPort::UnsupportedOperationError;
266 QTest::newRow("Unbuffered") << int(QIODevice::Unbuffered) << false << QSerialPort::UnsupportedOperationError;
267 }
268
269 void tst_QSerialPort::openExisting()
270 {
271 QFETCH(int, openMode);
272 QFETCH(bool, openResult);
273 QFETCH(QSerialPort::SerialPortError, errorCode);
274
275 for (const QString &serialPortName : std::as_const(m_availablePortNames)) {
276 QSerialPort serialPort(serialPortName);
277 QSignalSpy errorSpy(&serialPort, &QSerialPort::errorOccurred);
278 QVERIFY(errorSpy.isValid());
279
280 QCOMPARE(serialPort.portName(), serialPortName);
281 QCOMPARE(serialPort.open(QIODevice::OpenMode(openMode)), openResult);
282 QCOMPARE(serialPort.isOpen(), openResult);
283 QCOMPARE(serialPort.error(), errorCode);
284
285 QCOMPARE(errorSpy.size(), 1);
286 QCOMPARE(qvariant_cast<QSerialPort::SerialPortError>(errorSpy.at(0).at(0)), errorCode);
287 }
288 }
289
290 void tst_QSerialPort::openNotExisting_data()
291 {
292 QTest::addColumn<QString>("serialPortName");
293 QTest::addColumn<bool>("openResult");
294 QTest::addColumn<QSerialPort::SerialPortError>("errorCode");
295
296 QTest::newRow("Empty") << QString("") << false << QSerialPort::DeviceNotFoundError;
297 QTest::newRow("Null") << QString() << false << QSerialPort::DeviceNotFoundError;
298 QTest::newRow("NotExists") << QString("ABCDEF") << false << QSerialPort::DeviceNotFoundError;
299 }
300
301 void tst_QSerialPort::openNotExisting()
302 {
303 QFETCH(QString, serialPortName);
304 QFETCH(bool, openResult);
305 //QFETCH(QSerialPort::SerialPortError, errorCode);
306
307 QSerialPort serialPort(serialPortName);
308
309 QSignalSpy errorSpy(&serialPort, &QSerialPort::errorOccurred);
310 QVERIFY(errorSpy.isValid());
311
312 QCOMPARE(serialPort.portName(), serialPortName);
313 QCOMPARE(serialPort.open(QIODevice::ReadOnly), openResult);
314 QCOMPARE(serialPort.isOpen(), openResult);
315 //QCOMPARE(serialPort.error(), errorCode);
316
317 //QCOMPARE(errorSpy.count(), 1);
318 //QCOMPARE(qvariant_cast<QSerialPort::SerialPortError>(errorSpy.at(0).at(0)), errorCode);
319 }
320
321 void tst_QSerialPort::baudRate_data()
322 {
323 QTest::addColumn<qint32>("baudrate");
324 QTest::newRow("Baud1200") << static_cast<qint32>(QSerialPort::Baud1200);
325 QTest::newRow("Baud2400") << static_cast<qint32>(QSerialPort::Baud2400);
326 QTest::newRow("Baud4800") << static_cast<qint32>(QSerialPort::Baud4800);
327 QTest::newRow("Baud9600") << static_cast<qint32>(QSerialPort::Baud9600);
328 QTest::newRow("Baud19200") << static_cast<qint32>(QSerialPort::Baud19200);
329 QTest::newRow("Baud38400") << static_cast<qint32>(QSerialPort::Baud38400);
330 QTest::newRow("Baud57600") << static_cast<qint32>(QSerialPort::Baud57600);
331 QTest::newRow("Baud115200") << static_cast<qint32>(QSerialPort::Baud115200);
332
333 QTest::newRow("31250") << 31250; // custom baudrate (MIDI)
334 }
335
336 void tst_QSerialPort::baudRate()
337 {
338 QFETCH(qint32, baudrate);
339
340 {
341 // setup before opening
342 QSerialPort serialPort(m_senderPortName);
343 QVERIFY(serialPort.setBaudRate(baudrate));
344 QCOMPARE(serialPort.baudRate(), baudrate);
345 QVERIFY(serialPort.open(QIODevice::ReadWrite));
346 }
347
348 {
349 // setup after opening
350 QSerialPort serialPort(m_senderPortName);
351 QVERIFY(serialPort.open(QIODevice::ReadWrite));
352 QVERIFY(serialPort.setBaudRate(baudrate));
353 QCOMPARE(serialPort.baudRate(), baudrate);
354 }
355 }
356
357 void tst_QSerialPort::dataBits_data()
358 {
359 QTest::addColumn<QSerialPort::DataBits>("databits");
360 QTest::newRow("Data5") << QSerialPort::Data5;
361 QTest::newRow("Data6") << QSerialPort::Data6;
362 QTest::newRow("Data7") << QSerialPort::Data7;
363 QTest::newRow("Data8") << QSerialPort::Data8;
364 }
365
366 void tst_QSerialPort::dataBits()
367 {
368 QFETCH(QSerialPort::DataBits, databits);
369
370 {
371 // setup before opening
372 QSerialPort serialPort(m_senderPortName);
373 QVERIFY(serialPort.setDataBits(databits));
374 QCOMPARE(serialPort.dataBits(), databits);
375 QVERIFY(serialPort.open(QIODevice::ReadWrite));
376 }
377
378 {
379 // setup after opening
380 QSerialPort serialPort(m_senderPortName);
381 QVERIFY(serialPort.open(QIODevice::ReadWrite));
382 QVERIFY(serialPort.setDataBits(databits));
383 QCOMPARE(serialPort.dataBits(), databits);
384 }
385 }
386
387 void tst_QSerialPort::parity_data()
388 {
389 QTest::addColumn<QSerialPort::Parity>("parity");
390 QTest::newRow("NoParity") << QSerialPort::NoParity;
391 QTest::newRow("EvenParity") << QSerialPort::EvenParity;
392 QTest::newRow("OddParity") << QSerialPort::OddParity;
393 QTest::newRow("SpaceParity") << QSerialPort::SpaceParity;
394 QTest::newRow("MarkParity") << QSerialPort::MarkParity;
395 }
396
397 void tst_QSerialPort::parity()
398 {
399 QFETCH(QSerialPort::Parity, parity);
400
401 {
402 // setup before opening
403 QSerialPort serialPort(m_senderPortName);
404 QVERIFY(serialPort.setParity(parity));
405 QCOMPARE(serialPort.parity(), parity);
406 QVERIFY(serialPort.open(QIODevice::ReadWrite));
407 }
408
409 {
410 // setup after opening
411 QSerialPort serialPort(m_senderPortName);
412 QVERIFY(serialPort.open(QIODevice::ReadWrite));
413 QVERIFY(serialPort.setParity(parity));
414 QCOMPARE(serialPort.parity(), parity);
415 }
416 }
417
418 void tst_QSerialPort::stopBits_data()
419 {
420 QTest::addColumn<QSerialPort::StopBits>("stopbits");
421 QTest::newRow("OneStop") << QSerialPort::OneStop;
422 #ifdef Q_OS_WIN
423 QTest::newRow("OneAndHalfStop") << QSerialPort::OneAndHalfStop;
424 #endif
425 QTest::newRow("TwoStop") << QSerialPort::TwoStop;
426 }
427
428 void tst_QSerialPort::stopBits()
429 {
430 QFETCH(QSerialPort::StopBits, stopbits);
431
432 {
433 // setup before opening
434 QSerialPort serialPort(m_senderPortName);
435 QVERIFY(serialPort.setStopBits(stopbits));
436 QCOMPARE(serialPort.stopBits(), stopbits);
437 QVERIFY(serialPort.open(QIODevice::ReadWrite));
438 }
439
440 {
441 // setup after opening
442 QSerialPort serialPort(m_senderPortName);
443 QVERIFY(serialPort.open(QIODevice::ReadWrite));
444 QVERIFY(serialPort.setStopBits(stopbits));
445 QCOMPARE(serialPort.stopBits(), stopbits);
446 }
447 }
448
449 void tst_QSerialPort::flowControl_data()
450 {
451 QTest::addColumn<QSerialPort::FlowControl>("flowcontrol");
452 QTest::newRow("NoFlowControl") << QSerialPort::NoFlowControl;
453 QTest::newRow("HardwareControl") << QSerialPort::HardwareControl;
454 QTest::newRow("SoftwareControl") << QSerialPort::SoftwareControl;
455 }
456
457 void tst_QSerialPort::flowControl()
458 {
459 QFETCH(QSerialPort::FlowControl, flowcontrol);
460
461 {
462 // setup before opening
463 QSerialPort serialPort(m_senderPortName);
464 QVERIFY(serialPort.setFlowControl(flowcontrol));
465 QCOMPARE(serialPort.flowControl(), flowcontrol);
466 QVERIFY(serialPort.open(QIODevice::ReadWrite));
467 }
468
469 {
470 // setup after opening
471 QSerialPort serialPort(m_senderPortName);
472 QVERIFY(serialPort.open(QIODevice::ReadWrite));
473 QVERIFY(serialPort.setFlowControl(flowcontrol));
474 QCOMPARE(serialPort.flowControl(), flowcontrol);
475 }
476 }
477
478 void tst_QSerialPort::rts()
479 {
480 QSerialPort serialPort(m_senderPortName);
481
482 QSignalSpy errorSpy(&serialPort, &QSerialPort::errorOccurred);
483 QVERIFY(errorSpy.isValid());
484 QSignalSpy rtsSpy(&serialPort, &QSerialPort::requestToSendChanged);
485 QVERIFY(rtsSpy.isValid());
486
487 QVERIFY(serialPort.open(QIODevice::ReadWrite));
488
489 // no flow control
490 QVERIFY(serialPort.setFlowControl(QSerialPort::NoFlowControl));
491 const bool toggle1 = !serialPort.isRequestToSend();
492 QVERIFY(serialPort.setRequestToSend(toggle1));
493 QCOMPARE(serialPort.isRequestToSend(), toggle1);
494
495 // software flow control
496 QVERIFY(serialPort.setFlowControl(QSerialPort::SoftwareControl));
497 const bool toggle2 = !serialPort.isRequestToSend();
498 QVERIFY(serialPort.setRequestToSend(toggle2));
499 QCOMPARE(serialPort.isRequestToSend(), toggle2);
500
501 // hardware flow control
502 QVERIFY(serialPort.setFlowControl(QSerialPort::HardwareControl));
503 const bool toggle3 = !serialPort.isRequestToSend();
504 QVERIFY(!serialPort.setRequestToSend(toggle3)); // not allowed
505 QCOMPARE(serialPort.isRequestToSend(), !toggle3); // same as before
506 QCOMPARE(serialPort.error(), QSerialPort::UnsupportedOperationError);
507
508 QCOMPARE(errorSpy.size(), 2);
509 QCOMPARE(qvariant_cast<QSerialPort::SerialPortError>(errorSpy.at(0).at(0)), QSerialPort::NoError);
510 QCOMPARE(qvariant_cast<QSerialPort::SerialPortError>(errorSpy.at(1).at(0)), QSerialPort::UnsupportedOperationError);
511
512 QCOMPARE(rtsSpy.size(), 2);
513 QCOMPARE(qvariant_cast<bool>(rtsSpy.at(0).at(0)), toggle1);
514 QCOMPARE(qvariant_cast<bool>(rtsSpy.at(1).at(0)), toggle2);
515 }
516
517 void tst_QSerialPort::dtr()
518 {
519 QSerialPort serialPort(m_senderPortName);
520
521 QSignalSpy errorSpy(&serialPort, &QSerialPort::errorOccurred);
522 QVERIFY(errorSpy.isValid());
523 QSignalSpy dtrSpy(&serialPort, &QSerialPort::dataTerminalReadyChanged);
524 QVERIFY(dtrSpy.isValid());
525
526 QVERIFY(serialPort.open(QIODevice::ReadWrite));
527
528 // no flow control
529 QVERIFY(serialPort.setFlowControl(QSerialPort::NoFlowControl));
530 const bool toggle1 = !serialPort.isDataTerminalReady();
531 QVERIFY(serialPort.setDataTerminalReady(toggle1));
532 QCOMPARE(serialPort.isDataTerminalReady(), toggle1);
533
534 // software flow control
535 QVERIFY(serialPort.setFlowControl(QSerialPort::SoftwareControl));
536 const bool toggle2 = !serialPort.isDataTerminalReady();
537 QVERIFY(serialPort.setDataTerminalReady(toggle2));
538 QCOMPARE(serialPort.isDataTerminalReady(), toggle2);
539
540 // hardware flow control
541 QVERIFY(serialPort.setFlowControl(QSerialPort::HardwareControl));
542 const bool toggle3 = !serialPort.isDataTerminalReady();
543 QVERIFY(serialPort.setDataTerminalReady(toggle3));
544 QCOMPARE(serialPort.isDataTerminalReady(), toggle3);
545
546 QCOMPARE(errorSpy.size(), 1);
547 QCOMPARE(qvariant_cast<QSerialPort::SerialPortError>(errorSpy.at(0).at(0)), QSerialPort::NoError);
548
549 QCOMPARE(dtrSpy.size(), 3);
550 QCOMPARE(qvariant_cast<bool>(dtrSpy.at(0).at(0)), toggle1);
551 QCOMPARE(qvariant_cast<bool>(dtrSpy.at(1).at(0)), toggle2);
552 QCOMPARE(qvariant_cast<bool>(dtrSpy.at(2).at(0)), toggle3);
553 }
554
555 void tst_QSerialPort::independenceRtsAndDtr()
556 {
557 QSerialPort serialPort(m_senderPortName);
558 QVERIFY(serialPort.open(QIODevice::ReadWrite)); // No flow control by default!
559
560 QVERIFY(serialPort.setDataTerminalReady(true));
561 QVERIFY(serialPort.setRequestToSend(true));
562 QVERIFY(serialPort.isDataTerminalReady());
563 QVERIFY(serialPort.isRequestToSend());
564
565 // check that DTR changing does not change RTS
566 QVERIFY(serialPort.setDataTerminalReady(false));
567 QVERIFY(!serialPort.isDataTerminalReady());
568 QVERIFY(serialPort.isRequestToSend());
569 QVERIFY(serialPort.setDataTerminalReady(true));
570 QVERIFY(serialPort.isDataTerminalReady());
571 QVERIFY(serialPort.isRequestToSend());
572
573 // check that RTS changing does not change DTR
574 QVERIFY(serialPort.setRequestToSend(false));
575 QVERIFY(!serialPort.isRequestToSend());
576 QVERIFY(serialPort.isDataTerminalReady());
577 QVERIFY(serialPort.setRequestToSend(true));
578 QVERIFY(serialPort.isRequestToSend());
579 QVERIFY(serialPort.isDataTerminalReady());
580
581 // check that baud rate changing does not change DTR or RTS
582 QVERIFY(serialPort.setBaudRate(115200));
583 QVERIFY(serialPort.isRequestToSend());
584 QVERIFY(serialPort.isDataTerminalReady());
585
586 // check that data bits changing does not change DTR or RTS
587 QVERIFY(serialPort.setDataBits(QSerialPort::Data7));
588 QVERIFY(serialPort.isRequestToSend());
589 QVERIFY(serialPort.isDataTerminalReady());
590
591 // check that parity changing does not change DTR or RTS
592 QVERIFY(serialPort.setParity(QSerialPort::EvenParity));
593 QVERIFY(serialPort.isRequestToSend());
594 QVERIFY(serialPort.isDataTerminalReady());
595
596 // check that stop bits changing does not change DTR or RTS
597 QVERIFY(serialPort.setStopBits(QSerialPort::TwoStop));
598 QVERIFY(serialPort.isRequestToSend());
599 QVERIFY(serialPort.isDataTerminalReady());
600
601 // check that software flow control changing does not change DTR or RTS
602 QVERIFY(serialPort.setFlowControl(QSerialPort::SoftwareControl));
603 QVERIFY(serialPort.isRequestToSend());
604 QVERIFY(serialPort.isDataTerminalReady());
605 }
606
607 void tst_QSerialPort::handleBytesWrittenAndExitLoopSlot(qint64 bytesWritten)
608 {
609 QCOMPARE(bytesWritten, qint64(alphabetArray.size() + newlineArray.size()));
610 exitLoop();
611 }
612
613 void tst_QSerialPort::flush()
614 {
615 #ifdef Q_OS_WIN
616 QSKIP("flush() does not work on Windows");
617 #endif
618
619 // the dummy device on other side also has to be open
620 QSerialPort dummySerialPort(m_receiverPortName);
621 QVERIFY(dummySerialPort.open(QIODevice::ReadOnly));
622
623 QSerialPort serialPort(m_senderPortName);
624 connect(&serialPort, &QSerialPort::bytesWritten, this, &tst_QSerialPort::handleBytesWrittenAndExitLoopSlot);
625 QSignalSpy bytesWrittenSpy(&serialPort, &QSerialPort::bytesWritten);
626
627 QVERIFY(serialPort.open(QIODevice::WriteOnly));
628 serialPort.write(alphabetArray + newlineArray);
629 QCOMPARE(serialPort.bytesToWrite(), qint64(alphabetArray.size() + newlineArray.size()));
630 serialPort.flush();
631 QCOMPARE(serialPort.bytesToWrite(), qint64(0));
632 enterLoop(1);
633 QVERIFY2(!timeout(), "Timed out when waiting for the bytesWritten(qint64) signal.");
634 QCOMPARE(bytesWrittenSpy.size(), 1);
635 }
636
637 void tst_QSerialPort::handleBytesWrittenAndExitLoopSlot2(qint64 bytesWritten)
638 {
639 static qint64 bytes = 0;
640 bytes += bytesWritten;
641
642 QVERIFY(bytesWritten == newlineArray.size() || bytesWritten == alphabetArray.size());
643
644 if (bytes == (alphabetArray.size() + newlineArray.size()))
645 exitLoop();
646 }
647
648 void tst_QSerialPort::doubleFlush()
649 {
650 #ifdef Q_OS_WIN
651 QSKIP("flush() does not work on Windows");
652 #endif
653
654 // the dummy device on other side also has to be open
655 QSerialPort dummySerialPort(m_receiverPortName);
656 QVERIFY(dummySerialPort.open(QIODevice::ReadOnly));
657
658 QSerialPort serialPort(m_senderPortName);
659 connect(&serialPort, &QSerialPort::bytesWritten, this, &tst_QSerialPort::handleBytesWrittenAndExitLoopSlot2);
660 QSignalSpy bytesWrittenSpy(&serialPort, &QSerialPort::bytesWritten);
661
662 QVERIFY(serialPort.open(QIODevice::WriteOnly));
663 serialPort.write(alphabetArray);
664 QCOMPARE(serialPort.bytesToWrite(), qint64(alphabetArray.size()));
665 serialPort.flush();
666 QCOMPARE(serialPort.bytesToWrite(), qint64(0));
667 serialPort.write(newlineArray);
668 QCOMPARE(serialPort.bytesToWrite(), qint64(newlineArray.size()));
669 serialPort.flush();
670 QCOMPARE(serialPort.bytesToWrite(), qint64(0));
671
672 enterLoop(1);
673 QVERIFY2(!timeout(), "Timed out when waiting for the bytesWritten(qint64) signal.");
674 QCOMPARE(bytesWrittenSpy.size(), 2);
675 }
676
677 void tst_QSerialPort::waitForBytesWritten()
678 {
679 // the dummy device on other side also has to be open
680 QSerialPort dummySerialPort(m_receiverPortName);
681 QVERIFY(dummySerialPort.open(QIODevice::ReadOnly));
682
683 QSerialPort serialPort(m_senderPortName);
684 QVERIFY(serialPort.open(QIODevice::WriteOnly));
685 serialPort.write(alphabetArray);
686 const qint64 toWrite = serialPort.bytesToWrite();
687 QVERIFY(serialPort.waitForBytesWritten(1000));
688 QVERIFY(toWrite > serialPort.bytesToWrite());
689 }
690
691 void tst_QSerialPort::waitForReadyReadWithTimeout()
692 {
693 // the dummy device on other side also has to be open
694 QSerialPort dummySerialPort(m_senderPortName);
695 QVERIFY(dummySerialPort.open(QIODevice::WriteOnly));
696
697 QSerialPort receiverSerialPort(m_receiverPortName);
698 QVERIFY(receiverSerialPort.open(QIODevice::ReadOnly));
699 QVERIFY(!receiverSerialPort.waitForReadyRead(5));
700 QCOMPARE(receiverSerialPort.bytesAvailable(), qint64(0));
701 QCOMPARE(receiverSerialPort.error(), QSerialPort::TimeoutError);
702 }
703
704 void tst_QSerialPort::waitForReadyReadWithOneByte()
705 {
706 const qint64 oneByte = 1;
707 const int waitMsecs = 50;
708
709 QSerialPort senderSerialPort(m_senderPortName);
710 QVERIFY(senderSerialPort.open(QIODevice::WriteOnly));
711 QSerialPort receiverSerialPort(m_receiverPortName);
712 QSignalSpy readyReadSpy(&receiverSerialPort, &QSerialPort::readyRead);
713 QVERIFY(readyReadSpy.isValid());
714 QVERIFY(receiverSerialPort.open(QIODevice::ReadOnly));
715 QCOMPARE(senderSerialPort.write(alphabetArray.constData(), oneByte), oneByte);
716 QVERIFY(senderSerialPort.waitForBytesWritten(waitMsecs));
717 QVERIFY(receiverSerialPort.waitForReadyRead(waitMsecs));
718 QCOMPARE(receiverSerialPort.bytesAvailable(), oneByte);
719 QCOMPARE(receiverSerialPort.error(), QSerialPort::NoError);
720 QCOMPARE(readyReadSpy.size(), 1);
721 }
722
723 void tst_QSerialPort::waitForReadyReadWithAlphabet()
724 {
725 const int waitMsecs = 50;
726
727 QSerialPort senderSerialPort(m_senderPortName);
728 QVERIFY(senderSerialPort.open(QIODevice::WriteOnly));
729 QSerialPort receiverSerialPort(m_receiverPortName);
730 QSignalSpy readyReadSpy(&receiverSerialPort, &QSerialPort::readyRead);
731 QVERIFY(readyReadSpy.isValid());
732 QVERIFY(receiverSerialPort.open(QIODevice::ReadOnly));
733 QCOMPARE(senderSerialPort.write(alphabetArray), qint64(alphabetArray.size()));
734 QVERIFY(senderSerialPort.waitForBytesWritten(waitMsecs));
735
736 do {
737 QVERIFY(receiverSerialPort.waitForReadyRead(waitMsecs));
738 } while (receiverSerialPort.bytesAvailable() < qint64(alphabetArray.size()));
739
740 QCOMPARE(receiverSerialPort.error(), QSerialPort::NoError);
741 QVERIFY(readyReadSpy.size() > 0);
742 }
743
744 void tst_QSerialPort::twoStageSynchronousLoopback()
745 {
746 QSerialPort senderPort(m_senderPortName);
747 QVERIFY(senderPort.open(QSerialPort::ReadWrite));
748
749 QSerialPort receiverPort(m_receiverPortName);
750 QVERIFY(receiverPort.open(QSerialPort::ReadWrite));
751
752 const int waitMsecs = 50;
753
754 // first stage
755 senderPort.write(newlineArray);
756 senderPort.waitForBytesWritten(waitMsecs);
757 QTest::qSleep(waitMsecs);
758 receiverPort.waitForReadyRead(waitMsecs);
759 QCOMPARE(receiverPort.bytesAvailable(), qint64(newlineArray.size()));
760
761 receiverPort.write(receiverPort.readAll());
762 receiverPort.waitForBytesWritten(waitMsecs);
763 QTest::qSleep(waitMsecs);
764 senderPort.waitForReadyRead(waitMsecs);
765 QCOMPARE(senderPort.bytesAvailable(), qint64(newlineArray.size()));
766 QCOMPARE(senderPort.readAll(), newlineArray);
767
768 // second stage
769 senderPort.write(newlineArray);
770 senderPort.waitForBytesWritten(waitMsecs);
771 QTest::qSleep(waitMsecs);
772 receiverPort.waitForReadyRead(waitMsecs);
773 QCOMPARE(receiverPort.bytesAvailable(), qint64(newlineArray.size()));
774 receiverPort.write(receiverPort.readAll());
775 receiverPort.waitForBytesWritten(waitMsecs);
776 QTest::qSleep(waitMsecs);
777 senderPort.waitForReadyRead(waitMsecs);
778 QCOMPARE(senderPort.bytesAvailable(), qint64(newlineArray.size()));
779 QCOMPARE(senderPort.readAll(), newlineArray);
780 }
781
782 void tst_QSerialPort::synchronousReadWrite()
783 {
784 QSerialPort senderPort(m_senderPortName);
785 QVERIFY(senderPort.open(QSerialPort::WriteOnly));
786
787 QSerialPort receiverPort(m_receiverPortName);
788 QVERIFY(receiverPort.open(QSerialPort::ReadOnly));
789
790 QByteArray writeData;
791 for (int i = 0; i < 1024; ++i)
792 writeData.append(static_cast<char>(i));
793
794 senderPort.write(writeData);
795 senderPort.waitForBytesWritten(-1);
796
797 QByteArray readData;
798 while ((readData.size() < writeData.size()) && receiverPort.waitForReadyRead(100))
799 readData.append(receiverPort.readAll());
800
801 QCOMPARE(readData, writeData);
802 }
803
804 class AsyncReader : public QObject
805 {
806 Q_OBJECT
807 public:
808 explicit AsyncReader(QSerialPort &port, Qt::ConnectionType connectionType, int expectedBytesCount)
809 : serialPort(port), expectedBytesCount(expectedBytesCount)
810 {
811 connect(&serialPort, &QSerialPort::readyRead, this, &AsyncReader::receive, connectionType);
812 }
813
814 private slots:
815 void receive()
816 {
817 if (serialPort.bytesAvailable() < expectedBytesCount)
818 return;
819 tst_QSerialPort::exitLoop();
820 }
821
822 private:
823 QSerialPort &serialPort;
824 const int expectedBytesCount;
825 };
826
827 class AsyncWriterByBytesWritten : public QObject
828 {
829 Q_OBJECT
830 public:
831 explicit AsyncWriterByBytesWritten(
832 QSerialPort &port, Qt::ConnectionType connectionType, const QByteArray &dataToWrite)
833 : serialPort(port), writeChunkSize(0)
834 {
835 writeBuffer.setData(dataToWrite);
836 writeBuffer.open(QIODevice::ReadOnly);
837 connect(&serialPort, &QSerialPort::bytesWritten, this, &AsyncWriterByBytesWritten::send, connectionType);
838 send();
839 }
840
841 private slots:
842 void send()
843 {
844 if (writeBuffer.bytesAvailable() > 0)
845 serialPort.write(writeBuffer.read(++writeChunkSize));
846 }
847
848 private:
849 QSerialPort &serialPort;
850 QBuffer writeBuffer;
851 int writeChunkSize;
852 };
853
854 void tst_QSerialPort::asynchronousWriteByBytesWritten_data()
855 {
856 QTest::addColumn<Qt::ConnectionType>("readConnectionType");
857 QTest::addColumn<Qt::ConnectionType>("writeConnectionType");
858
859 QTest::newRow("BothQueued") << Qt::QueuedConnection << Qt::QueuedConnection;
860 QTest::newRow("BothDirect") << Qt::DirectConnection << Qt::DirectConnection;
861 QTest::newRow("ReadDirectWriteQueued") << Qt::DirectConnection << Qt::QueuedConnection;
862 QTest::newRow("ReadQueuedWriteDirect") << Qt::QueuedConnection << Qt::DirectConnection;
863 }
864
865 void tst_QSerialPort::asynchronousWriteByBytesWritten()
866 {
867 QFETCH(Qt::ConnectionType, readConnectionType);
868 QFETCH(Qt::ConnectionType, writeConnectionType);
869
870 QSerialPort receiverPort(m_receiverPortName);
871 QVERIFY(receiverPort.open(QSerialPort::ReadOnly));
872 AsyncReader reader(receiverPort, readConnectionType, alphabetArray.size());
873
874 QSerialPort senderPort(m_senderPortName);
875 QVERIFY(senderPort.open(QSerialPort::WriteOnly));
876 AsyncWriterByBytesWritten writer(senderPort, writeConnectionType, alphabetArray);
877
878 enterLoop(1);
879 QVERIFY2(!timeout(), "Timed out when waiting for the read or write.");
880 QCOMPARE(receiverPort.bytesAvailable(), qint64(alphabetArray.size()));
881 QCOMPARE(receiverPort.readAll(), alphabetArray);
882 }
883
884 class AsyncWriterByTimer : public QObject
885 {
886 Q_OBJECT
887 public:
888 explicit AsyncWriterByTimer(QSerialPort &port, Qt::ConnectionType connectionType,
889 const QByteArray &dataToWrite, int interval = 0)
890 : serialPort(port), writeChunkSize(0), timerMsec(interval)
891 {
892 writeBuffer.setData(dataToWrite);
893 writeBuffer.open(QIODevice::ReadOnly);
894 connect(&timer, &QTimer::timeout, this, &AsyncWriterByTimer::send, connectionType);
895 timer.start(timerMsec);
896 }
897
898 private slots:
899 void send()
900 {
901 if (writeBuffer.bytesAvailable() > 0)
902 serialPort.write(writeBuffer.read(++writeChunkSize));
903 else
904 timer.stop();
905 }
906
907 private:
908 QSerialPort &serialPort;
909 QBuffer writeBuffer;
910 int writeChunkSize;
911 QTimer timer;
912 int timerMsec;
913 };
914
915 void tst_QSerialPort::asynchronousWriteByTimer_data()
916 {
917 QTest::addColumn<Qt::ConnectionType>("readConnectionType");
918 QTest::addColumn<Qt::ConnectionType>("writeConnectionType");
919
920 QTest::newRow("BothQueued") << Qt::QueuedConnection << Qt::QueuedConnection;
921 QTest::newRow("BothDirect") << Qt::DirectConnection << Qt::DirectConnection;
922 QTest::newRow("ReadDirectWriteQueued") << Qt::DirectConnection << Qt::QueuedConnection;
923 QTest::newRow("ReadQueuedWriteDirect") << Qt::QueuedConnection << Qt::DirectConnection;
924 }
925
926 void tst_QSerialPort::asynchronousWriteByTimer()
927 {
928 QFETCH(Qt::ConnectionType, readConnectionType);
929 QFETCH(Qt::ConnectionType, writeConnectionType);
930
931 QSerialPort receiverPort(m_receiverPortName);
932 QVERIFY(receiverPort.open(QSerialPort::ReadOnly));
933 AsyncReader reader(receiverPort, readConnectionType, alphabetArray.size());
934
935 QSerialPort senderPort(m_senderPortName);
936 QVERIFY(senderPort.open(QSerialPort::WriteOnly));
937 AsyncWriterByTimer writer(senderPort, writeConnectionType, alphabetArray);
938
939 enterLoop(1);
940 QVERIFY2(!timeout(), "Timed out when waiting for the read or write.");
941 QCOMPARE(receiverPort.bytesAvailable(), qint64(alphabetArray.size()));
942 QCOMPARE(receiverPort.readAll(), alphabetArray);
943 }
944
945 class AsyncReader2 : public QObject
946 {
947 Q_OBJECT
948 public:
949 explicit AsyncReader2(QSerialPort &port, const QByteArray &expectedData)
950 : serialPort(port), expectedData(expectedData)
951 {
952 connect(&serialPort, &QSerialPort::readyRead, this, &AsyncReader2::receive);
953 }
954
955 private slots:
956 void receive()
957 {
958 receivedData.append(serialPort.readAll());
959 if (receivedData == expectedData)
960 tst_QSerialPort::exitLoop();
961 }
962
963 private:
964 QSerialPort &serialPort;
965 const QByteArray expectedData;
966 QByteArray receivedData;
967 };
968
969 void tst_QSerialPort::asyncReadWithLimitedReadBufferSize()
970 {
971 QSerialPort senderPort(m_senderPortName);
972 QVERIFY(senderPort.open(QSerialPort::WriteOnly));
973
974 QSerialPort receiverPort(m_receiverPortName);
975 QVERIFY(receiverPort.open(QSerialPort::ReadOnly));
976
977 receiverPort.setReadBufferSize(1);
978 QCOMPARE(receiverPort.readBufferSize(), qint64(1));
979
980 AsyncReader2 reader(receiverPort, alphabetArray);
981
982 QCOMPARE(senderPort.write(alphabetArray), qint64(alphabetArray.size()));
983
984 enterLoop(1);
985 QVERIFY2(!timeout(), "Timed out when waiting for the read or write.");
986 }
987
988 void tst_QSerialPort::readBufferOverflow()
989 {
990 QSerialPort senderPort(m_senderPortName);
991 QVERIFY(senderPort.open(QSerialPort::WriteOnly));
992
993 QSerialPort receiverPort(m_receiverPortName);
994 QVERIFY(receiverPort.open(QSerialPort::ReadOnly));
995
996 const int readBufferSize = alphabetArray.size() / 2;
997 receiverPort.setReadBufferSize(readBufferSize);
998 QCOMPARE(receiverPort.readBufferSize(), qint64(readBufferSize));
999
1000 QCOMPARE(senderPort.write(alphabetArray), qint64(alphabetArray.size()));
1001 QVERIFY2(senderPort.waitForBytesWritten(100), "Waiting for bytes written failed");
1002
1003 QByteArray readData;
1004 while (receiverPort.waitForReadyRead(100)) {
1005 QVERIFY(receiverPort.bytesAvailable() > 0);
1006 readData += receiverPort.readAll();
1007 }
1008
1009 QCOMPARE(readData, alphabetArray);
1010
1011 // No more bytes available
1012 QVERIFY(receiverPort.bytesAvailable() == 0);
1013 }
1014
1015 void tst_QSerialPort::readAfterInputClear()
1016 {
1017 QSerialPort senderPort(m_senderPortName);
1018 QVERIFY(senderPort.open(QSerialPort::WriteOnly));
1019
1020 QSerialPort receiverPort(m_receiverPortName);
1021 QVERIFY(receiverPort.open(QSerialPort::ReadOnly));
1022
1023 const int readBufferSize = alphabetArray.size() / 2;
1024 receiverPort.setReadBufferSize(readBufferSize);
1025 QCOMPARE(receiverPort.readBufferSize(), qint64(readBufferSize));
1026
1027 const int waitMsecs = 100;
1028
1029 // First write more than read buffer size
1030 QCOMPARE(senderPort.write(alphabetArray), qint64(alphabetArray.size()));
1031 QVERIFY2(senderPort.waitForBytesWritten(waitMsecs), "Waiting for bytes written failed");
1032
1033 // Wait for first part of data into read buffer
1034 while (receiverPort.waitForReadyRead(waitMsecs));
1035 QCOMPARE(receiverPort.bytesAvailable(), qint64(readBufferSize));
1036 // Wait for second part of data into driver's FIFO
1037 QTest::qSleep(waitMsecs);
1038
1039 QVERIFY(receiverPort.clear(QSerialPort::Input));
1040 QCOMPARE(receiverPort.bytesAvailable(), qint64(0));
1041
1042 // Second write less than read buffer size
1043 QCOMPARE(senderPort.write(newlineArray), qint64(newlineArray.size()));
1044 QVERIFY2(senderPort.waitForBytesWritten(waitMsecs), "Waiting for bytes written failed");
1045
1046 while (receiverPort.waitForReadyRead(waitMsecs));
1047 QCOMPARE(receiverPort.bytesAvailable(), qint64(newlineArray.size()));
1048 QCOMPARE(receiverPort.readAll(), newlineArray);
1049
1050 // No more bytes available
1051 QVERIFY(receiverPort.bytesAvailable() == 0);
1052 }
1053
1054 class SenderTransactor : public QObject
1055 {
1056 Q_OBJECT
1057 public:
1058 explicit SenderTransactor(const QString &name)
1059 : serialPort(name)
1060 {
1061 }
1062
1063 public slots:
1064 void open()
1065 {
1066 if (serialPort.open(QSerialPort::ReadWrite)) {
1067 createAsynchronousConnection();
1068 serialPort.write("A", 1);
1069 }
1070 }
1071
1072 private slots:
1073 void synchronousTransaction()
1074 {
1075 serialPort.write("B", 1);
1076 if (serialPort.waitForBytesWritten(100)) {
1077 if (serialPort.waitForReadyRead(100))
1078 tst_QSerialPort::exitLoop();
1079 }
1080 }
1081
1082 void transaction()
1083 {
1084 deleteAsyncronousConnection();
1085 synchronousTransaction();
1086 }
1087
1088 private:
1089 void createAsynchronousConnection()
1090 {
1091 connect(&serialPort, &QSerialPort::readyRead, this, &SenderTransactor::transaction);
1092 }
1093
1094 void deleteAsyncronousConnection()
1095 {
1096 serialPort.disconnect();
1097 }
1098
1099 QSerialPort serialPort;
1100 };
1101
1102 class ReceiverTransactor : public QObject
1103 {
1104 Q_OBJECT
1105 public:
1106 explicit ReceiverTransactor(const QString &name)
1107 : serialPort(new QSerialPort(name, this))
1108 {
1109 connect(serialPort, &QSerialPort::readyRead, this, &ReceiverTransactor::transaction);
1110 }
1111
1112 public slots:
1113 void open()
1114 {
1115 if (serialPort->open(QSerialPort::ReadWrite))
1116 emit ready();
1117 }
1118
1119 signals:
1120 void ready();
1121
1122 private slots:
1123 void transaction()
1124 {
1125 serialPort->write("Z", 1);
1126 }
1127
1128 private:
1129 QSerialPort *serialPort;
1130 };
1131
1132 void tst_QSerialPort::synchronousReadWriteAfterAsynchronousReadWrite()
1133 {
1134 SenderTransactor sender(m_senderPortName);
1135 auto receiver = new ReceiverTransactor(m_receiverPortName);
1136
1137 QThread thread;
1138 receiver->moveToThread(&thread);
1139 thread.start();
1140
1141 QObject::connect(&thread, &QThread::finished, receiver, &ReceiverTransactor::deleteLater);
1142 QObject::connect(receiver, &ReceiverTransactor::ready, &sender, &SenderTransactor::open);
1143
1144 QMetaObject::invokeMethod(receiver, "open", Qt::QueuedConnection);
1145
1146 tst_QSerialPort::enterLoopMsecs(2000);
1147
1148 thread.quit();
1149 thread.wait();
1150
1151 QVERIFY2(!timeout(), "Timed out when testing of transactions.");
1152 }
1153
1154 class BreakReader : public QObject
1155 {
1156 Q_OBJECT
1157 public:
1158 explicit BreakReader(QSerialPort &port)
1159 : serialPort(port)
1160 {
1161 connect(&serialPort, &QSerialPort::readyRead, this, &BreakReader::receive);
1162 }
1163
1164 private slots:
1165 void receive()
1166 {
1167 tst_QSerialPort::exitLoop();
1168 }
1169
1170 private:
1171 QSerialPort &serialPort;
1172 };
1173
1174 void tst_QSerialPort::controlBreak()
1175 {
1176 QSerialPort senderPort(m_senderPortName);
1177 QVERIFY(senderPort.open(QSerialPort::WriteOnly));
1178 QCOMPARE(senderPort.isBreakEnabled(), false);
1179
1180 QSignalSpy breakSpy(&senderPort, &QSerialPort::breakEnabledChanged);
1181 QVERIFY(breakSpy.isValid());
1182
1183 QSerialPort receiverPort(m_receiverPortName);
1184 QVERIFY(receiverPort.open(QSerialPort::ReadOnly));
1185
1186 BreakReader reader(receiverPort);
1187
1188 QVERIFY(senderPort.setBreakEnabled(true));
1189 QCOMPARE(senderPort.isBreakEnabled(), true);
1190
1191 enterLoop(1);
1192 QVERIFY2(!timeout(), "Timed out when waiting for the read of break state.");
1193 QVERIFY(receiverPort.bytesAvailable() > 0);
1194
1195 const QByteArray actual = receiverPort.readAll();
1196 const QByteArray expected(actual.size(), '\0');
1197 QCOMPARE(actual, expected);
1198
1199 QVERIFY(senderPort.setBreakEnabled(false));
1200 QCOMPARE(senderPort.isBreakEnabled(), false);
1201
1202 QCOMPARE(breakSpy.size(), 2);
1203 QCOMPARE(qvariant_cast<bool>(breakSpy.at(0).at(0)), true);
1204 QCOMPARE(qvariant_cast<bool>(breakSpy.at(1).at(0)), false);
1205 }
1206
1207 void tst_QSerialPort::clearAfterOpen()
1208 {
1209 QSerialPort senderPort(m_senderPortName);
1210 QVERIFY(senderPort.open(QSerialPort::ReadWrite));
1211 QCOMPARE(senderPort.error(), QSerialPort::NoError);
1212 QVERIFY(senderPort.clear());
1213 QCOMPARE(senderPort.error(), QSerialPort::NoError);
1214 }
1215
1216 void tst_QSerialPort::readWriteWithDifferentBaudRate_data()
1217 {
1218 QTest::addColumn<int>("senderBaudRate");
1219 QTest::addColumn<int>("receiverBaudRate");
1220 QTest::addColumn<bool>("expectedResult");
1221
1222 QTest::newRow("9600, 9600") << 9600 << 9600 << true;
1223 QTest::newRow("115200, 115200") << 115200 << 115200 << true;
1224 QTest::newRow("9600, 115200") << 9600 << 115200 << false;
1225
1226 QTest::newRow("31250, 31250") << 31250 << 31250 << true; // custom baudrate (MIDI)
1227 QTest::newRow("31250, 115200") << 31250 << 115200 << false;
1228
1229 #ifdef Q_OS_LINUX
1230 QTest::newRow("14400, 14400") << 14400 << 14400 << true; // custom baudrate for Linux
1231 QTest::newRow("14400, 115200") << 14400 << 115200 << false;
1232 #endif
1233 }
1234
1235 void tst_QSerialPort::readWriteWithDifferentBaudRate()
1236 {
1237 QFETCH(int, senderBaudRate);
1238 QFETCH(int, receiverBaudRate);
1239 QFETCH(bool, expectedResult);
1240
1241 {
1242 // setup before opening
1243 QSerialPort senderSerialPort(m_senderPortName);
1244 QVERIFY(senderSerialPort.setBaudRate(senderBaudRate));
1245 QCOMPARE(senderSerialPort.baudRate(), senderBaudRate);
1246 QVERIFY(senderSerialPort.open(QSerialPort::ReadWrite));
1247 QSerialPort receiverSerialPort(m_receiverPortName);
1248 QVERIFY(receiverSerialPort.setBaudRate(receiverBaudRate));
1249 QCOMPARE(receiverSerialPort.baudRate(), receiverBaudRate);
1250 QVERIFY(receiverSerialPort.open(QSerialPort::ReadWrite));
1251
1252 QCOMPARE(senderSerialPort.write(alphabetArray), qint64(alphabetArray.size()));
1253 QVERIFY(senderSerialPort.waitForBytesWritten(500));
1254
1255 do {
1256 QVERIFY(receiverSerialPort.waitForReadyRead(500));
1257 } while (receiverSerialPort.bytesAvailable() < alphabetArray.size());
1258
1259 if (expectedResult)
1260 QVERIFY(receiverSerialPort.readAll() == alphabetArray);
1261 else
1262 QVERIFY(receiverSerialPort.readAll() != alphabetArray);
1263 }
1264
1265 {
1266 // setup after opening
1267 QSerialPort senderSerialPort(m_senderPortName);
1268 QVERIFY(senderSerialPort.open(QSerialPort::ReadWrite));
1269 QVERIFY(senderSerialPort.setBaudRate(senderBaudRate));
1270 QCOMPARE(senderSerialPort.baudRate(), senderBaudRate);
1271 QSerialPort receiverSerialPort(m_receiverPortName);
1272 QVERIFY(receiverSerialPort.open(QSerialPort::ReadWrite));
1273 QVERIFY(receiverSerialPort.setBaudRate(receiverBaudRate));
1274 QCOMPARE(receiverSerialPort.baudRate(), receiverBaudRate);
1275
1276 QCOMPARE(senderSerialPort.write(alphabetArray), qint64(alphabetArray.size()));
1277 QVERIFY(senderSerialPort.waitForBytesWritten(500));
1278
1279 do {
1280 QVERIFY(receiverSerialPort.waitForReadyRead(500));
1281 } while (receiverSerialPort.bytesAvailable() < alphabetArray.size());
1282
1283 if (expectedResult)
1284 QVERIFY(receiverSerialPort.readAll() == alphabetArray);
1285 else
1286 QVERIFY(receiverSerialPort.readAll() != alphabetArray);
1287 }
1288 }
1289
1290 void tst_QSerialPort::readWriteWithMarkSpaceParity_data()
1291 {
1292 QTest::addColumn<QSerialPort::Parity>("parity");
1293
1294 QTest::newRow("parity_space") << QSerialPort::SpaceParity;
1295 QTest::newRow("parity_mark") << QSerialPort::MarkParity;
1296 }
1297
1298 void tst_QSerialPort::readWriteWithMarkSpaceParity()
1299 {
1300 QFETCH(const QSerialPort::Parity, parity);
1301
1302 auto setupPort = [&parity](QSerialPort &port) {
1303 port.setBaudRate(QSerialPort::Baud9600);
1304 port.setParity(parity);
1305 port.setDataBits(QSerialPort::Data8);
1306 port.setStopBits(QSerialPort::OneStop);
1307 };
1308
1309 QSerialPort sender(m_senderPortName);
1310 QSignalSpy senderSpy(&sender, &QSerialPort::bytesWritten);
1311 setupPort(sender);
1312 QVERIFY(sender.open(QIODevice::ReadWrite));
1313
1314 QSerialPort receiver(m_receiverPortName);
1315 QSignalSpy receiverSpy(&receiver, &QSerialPort::readyRead);
1316 setupPort(receiver);
1317 QVERIFY(receiver.open(QIODevice::ReadWrite));
1318
1319 const QByteArray data("some data");
1320 const qint64 written = sender.write(data);
1321 QCOMPARE(written, qint64(data.size()));
1322 QTRY_COMPARE(senderSpy.size(), 1);
1323 QCOMPARE(senderSpy.at(0).at(0).value<qint64>(), written);
1324
1325 QTRY_COMPARE_GE(receiver.bytesAvailable(), written);
1326 QCOMPARE_GE(receiverSpy.size(), 1); // we should get *at least one* signal
1327
1328 #if !defined(Q_OS_UNIX) || defined(CMSPAR)
1329 // On UNIX with no CMSPAR the result is flaky, so we cannot even use
1330 // QEXPECT_FAIL(). See QTBUG-131679.
1331 const QByteArray receivedData = receiver.readAll();
1332 QCOMPARE(receivedData, data);
1333 #endif
1334 }
1335
1336 void tst_QSerialPort::bindingsAndProperties()
1337 {
1338 QSerialPort sp;
1339
1340 // -- data bits
1341
1342 QTestPrivate::testReadWritePropertyBasics(sp, QSerialPort::DataBits::Data6,
1343 QSerialPort::DataBits::Data5, "dataBits");
1344 if (QTest::currentTestFailed()) {
1345 qDebug("Failed property test for QSetialPort::dataBits");
1346 return;
1347 }
1348
1349 // -- parity
1350
1351 QTestPrivate::testReadWritePropertyBasics(sp, QSerialPort::Parity::SpaceParity,
1352 QSerialPort::Parity::EvenParity, "parity");
1353 if (QTest::currentTestFailed()) {
1354 qDebug("Failed property test for QSetialPort::parity");
1355 return;
1356 }
1357
1358 // -- stop bits
1359
1360 static_assert(std::is_same_v<decltype(sp.bindableStopBits()),
1361 QBindable<QSerialPort::StopBits>>);
1362
1363 QTestPrivate::testReadWritePropertyBasics(sp, QSerialPort::StopBits::OneAndHalfStop,
1364 QSerialPort::StopBits::TwoStop, "stopBits");
1365 if (QTest::currentTestFailed()) {
1366 qDebug("Failed property test for QSetialPort::stopBits");
1367 return;
1368 }
1369
1370 // -- flow control
1371
1372 QTestPrivate::testReadWritePropertyBasics(sp, QSerialPort::FlowControl::HardwareControl,
1373 QSerialPort::FlowControl::SoftwareControl,
1374 "flowControl");
1375 if (QTest::currentTestFailed()) {
1376 qDebug("Failed property test for QSetialPort::flowControl");
1377 return;
1378 }
1379
1380 // -- error
1381
1382 QTestPrivate::testReadOnlyPropertyBasics(
1383 sp, QSerialPort::SerialPortError::NoError,
1384 QSerialPort::SerialPortError::UnsupportedOperationError, "error",
1385 [&sp]() { sp.open(QIODevice::Truncate); });
1386 if (QTest::currentTestFailed()) {
1387 qDebug("Failed property test for QSetialPort::error");
1388 return;
1389 }
1390
1391 // -- break enabled
1392
1393 sp.setPortName(m_receiverPortName);
1394 const bool portOpened = sp.open(QIODevice::ReadOnly);
1395
1396 if (portOpened) {
1397 // To test the binding loop we need to create another instance of
1398 // QSerialPort, open it, and set breakEnabled == true as a default
1399 // value, so use a custom lambda for that.
1400 QTestPrivate::testReadWritePropertyBasics<QSerialPort, bool>(
1401 sp, true, false, "breakEnabled",
1402 [name = this->m_senderPortName]() {
1403 auto ptr = std::make_unique<QSerialPort>();
1404 ptr->setPortName(name);
1405 if (ptr->open(QIODevice::ReadOnly)) {
1406 ptr->setBreakEnabled(true);
1407 return ptr;
1408 }
1409 // skip binding loop test if we failed to open the port
1410 return std::unique_ptr<QSerialPort>{};
1411 });
1412 if (QTest::currentTestFailed()) {
1413 qDebug("Failed property test for QSetialPort::breakEnabled");
1414 return;
1415 }
1416 } else {
1417 // setting isBreakEnabled() will return false and raise an error
1418 sp.setBreakEnabled(true);
1419 QCOMPARE(sp.error(), QSerialPort::SerialPortError::NotOpenError);
1420 }
1421 }
1422
1423 class PlatformSettings
1424 {
1425 public:
1426 explicit PlatformSettings(const QString &portName) : portInfo(portName) {}
1427
1428 void getPortSettings();
1429 void restorePortSettings();
1430 private:
1431 friend bool operator==(const PlatformSettings &lhs, const PlatformSettings &rhs);
1432 friend bool operator!=(const PlatformSettings &lhs, const PlatformSettings &rhs)
1433 { return !operator==(lhs, rhs); }
1434
1435
1436 QSerialPortInfo portInfo;
1437 #ifdef Q_OS_UNIX
1438 termios tio;
1439 #elif defined(Q_OS_WIN)
1440 DCB dcb;
1441 COMMTIMEOUTS commTimeouts;
1442 #endif
1443 };
1444
1445 void PlatformSettings::getPortSettings()
1446 {
1447 #ifdef Q_OS_UNIX
1448 const int flags = O_NOCTTY | O_NONBLOCK | O_RDONLY;
1449 int descriptor = qt_safe_open(portInfo.systemLocation().toLocal8Bit().constData(), flags);
1450 ::memset(&tio, 0, sizeof(termios));
1451 ::tcgetattr(descriptor, &tio);
1452 qt_safe_close(descriptor);
1453 #elif defined(Q_OS_WIN)
1454 auto handle = ::CreateFile(reinterpret_cast<const wchar_t*>(portInfo.systemLocation().utf16()),
1455 GENERIC_READ, 0, nullptr, OPEN_EXISTING, FILE_FLAG_OVERLAPPED,
1456 nullptr);
1457 ::ZeroMemory(&dcb, sizeof(DCB));
1458 dcb.DCBlength = sizeof(DCB);
1459 ::GetCommState(handle, &dcb);
1460 ::GetCommTimeouts(handle, &commTimeouts);
1461 CloseHandle(handle);
1462 #endif
1463 }
1464
1465 void PlatformSettings::restorePortSettings()
1466 {
1467 #ifdef Q_OS_UNIX
1468 const int flags = O_NOCTTY | O_NONBLOCK | O_RDONLY;
1469 int descriptor = qt_safe_open(portInfo.systemLocation().toLocal8Bit().constData(), flags);
1470 ::tcsetattr(descriptor, TCSANOW, &tio);
1471 qt_safe_close(descriptor);
1472 #elif defined(Q_OS_WIN)
1473 auto handle = ::CreateFile(reinterpret_cast<const wchar_t*>(portInfo.systemLocation().utf16()),
1474 GENERIC_READ, 0, nullptr, OPEN_EXISTING, FILE_FLAG_OVERLAPPED,
1475 nullptr);
1476 ::SetCommState(handle, &dcb);
1477 ::SetCommTimeouts(handle, &commTimeouts);
1478 CloseHandle(handle);
1479 #endif
1480 }
1481
1482 bool operator==(const PlatformSettings &lhs, const PlatformSettings &rhs)
1483 {
1484 #ifdef Q_OS_UNIX
1485 // compare only the minimal subset
1486 const bool tioEqual =
1487 lhs.tio.c_iflag == rhs.tio.c_iflag
1488 && lhs.tio.c_oflag == rhs.tio.c_oflag
1489 && lhs.tio.c_cflag == rhs.tio.c_cflag
1490 && lhs.tio.c_lflag == rhs.tio.c_lflag;
1491
1492 if (tioEqual) {
1493 const auto lhsISpeed = ::cfgetispeed(&lhs.tio);
1494 const auto lhsOSpeed = ::cfgetospeed(&lhs.tio);
1495
1496 const auto rhsISpeed = ::cfgetispeed(&rhs.tio);
1497 const auto rhsOSpeed = ::cfgetospeed(&rhs.tio);
1498
1499 return lhsISpeed == rhsISpeed && lhsOSpeed == rhsOSpeed;
1500 }
1501 return tioEqual;
1502 #elif defined(Q_OS_WIN)
1503 const bool timeoutsEqual =
1504 lhs.commTimeouts.ReadIntervalTimeout == rhs.commTimeouts.ReadIntervalTimeout
1505 && lhs.commTimeouts.ReadTotalTimeoutMultiplier == rhs.commTimeouts.ReadTotalTimeoutMultiplier
1506 && lhs.commTimeouts.ReadTotalTimeoutConstant == rhs.commTimeouts.ReadTotalTimeoutConstant
1507 && lhs.commTimeouts.WriteTotalTimeoutMultiplier == rhs.commTimeouts.WriteTotalTimeoutMultiplier
1508 && lhs.commTimeouts.WriteTotalTimeoutConstant == rhs.commTimeouts.WriteTotalTimeoutConstant;
1509
1510 const bool dcbEqual =
1511 lhs.dcb.DCBlength == rhs.dcb.DCBlength
1512 && lhs.dcb.BaudRate == rhs.dcb.BaudRate
1513 && lhs.dcb.fBinary == rhs.dcb.fBinary
1514 && lhs.dcb.fParity == rhs.dcb.fParity
1515 && lhs.dcb.fOutxCtsFlow == rhs.dcb.fOutxCtsFlow
1516 && lhs.dcb.fOutxDsrFlow == rhs.dcb.fOutxDsrFlow
1517 && lhs.dcb.fDtrControl == rhs.dcb.fDtrControl
1518 && lhs.dcb.fDsrSensitivity == rhs.dcb.fDsrSensitivity
1519 && lhs.dcb.fTXContinueOnXoff == rhs.dcb.fTXContinueOnXoff
1520 && lhs.dcb.fOutX == rhs.dcb.fOutX
1521 && lhs.dcb.fInX == rhs.dcb.fInX
1522 && lhs.dcb.fErrorChar == rhs.dcb.fErrorChar
1523 && lhs.dcb.fNull == rhs.dcb.fNull
1524 && lhs.dcb.fRtsControl == rhs.dcb.fRtsControl
1525 && lhs.dcb.fAbortOnError == rhs.dcb.fAbortOnError
1526 && lhs.dcb.wReserved == rhs.dcb.wReserved
1527 && lhs.dcb.XonLim == rhs.dcb.XonLim
1528 && lhs.dcb.XoffLim == rhs.dcb.XoffLim
1529 && lhs.dcb.ByteSize == rhs.dcb.ByteSize
1530 && lhs.dcb.Parity == rhs.dcb.Parity
1531 && lhs.dcb.StopBits == rhs.dcb.StopBits
1532 && lhs.dcb.XonChar == rhs.dcb.XonChar
1533 && lhs.dcb.XoffChar == rhs.dcb.XoffChar
1534 && lhs.dcb.ErrorChar == rhs.dcb.ErrorChar
1535 && lhs.dcb.EofChar == rhs.dcb.EofChar
1536 && lhs.dcb.EvtChar == rhs.dcb.EvtChar;
1537
1538 return timeoutsEqual && dcbEqual;
1539 #endif
1540 // general case
1541 return false;
1542 }
1543
1544 void tst_QSerialPort::restoreSettingsOnClose()
1545 {
1546 #ifndef Q_OS_APPLE
1547 PlatformSettings initialSettings(m_senderPortName);
1548 initialSettings.getPortSettings();
1549
1550 QSerialPort port(m_senderPortName);
1551 QVERIFY(port.settingsRestoredOnClose());
1552 QSignalSpy restoreOnCloseSpy(&port, &QSerialPort::settingsRestoredOnCloseChanged);
1553
1554 port.setSettingsRestoredOnClose(false);
1555 QVERIFY(!port.settingsRestoredOnClose());
1556 QCOMPARE(restoreOnCloseSpy.size(), 1);
1557 QCOMPARE(qvariant_cast<bool>(restoreOnCloseSpy.at(0).at(0)), false);
1558
1559 port.setBaudRate(QSerialPort::Baud115200);
1560 port.setDataBits(QSerialPort::Data7);
1561 port.setStopBits(QSerialPort::OneStop);
1562 port.setParity(QSerialPort::OddParity);
1563 port.setFlowControl(QSerialPort::HardwareControl);
1564
1565 // Open the port - new settings should be applied
1566 QVERIFY(port.open(QIODevice::ReadOnly));
1567 // Close the port - the same new settings should be kept
1568 port.close();
1569
1570 PlatformSettings settingsAfterClose(m_senderPortName);
1571 settingsAfterClose.getPortSettings();
1572
1573 QCOMPARE_NE(settingsAfterClose, initialSettings);
1574
1575 port.setSettingsRestoredOnClose(true);
1576 QVERIFY(port.settingsRestoredOnClose());
1577 QCOMPARE(restoreOnCloseSpy.size(), 2);
1578 QCOMPARE(qvariant_cast<bool>(restoreOnCloseSpy.at(1).at(0)), true);
1579
1580 port.setBaudRate(QSerialPort::Baud57600);
1581 port.setDataBits(QSerialPort::Data8);
1582 port.setParity(QSerialPort::NoParity);
1583 port.setFlowControl(QSerialPort::NoFlowControl);
1584
1585 // Open the port - new settings should be applied
1586 QVERIFY(port.open(QIODevice::ReadOnly));
1587 // Close the port - the old settings should be restored
1588 port.close();
1589
1590 PlatformSettings settingsAfterSecondClose(m_senderPortName);
1591 settingsAfterSecondClose.getPortSettings();
1592 QCOMPARE(settingsAfterSecondClose, settingsAfterClose);
1593 QCOMPARE_NE(settingsAfterSecondClose, initialSettings);
1594
1595 // restore the original settings
1596 initialSettings.restorePortSettings();
1597 #else
1598 QSKIP("macOS always resets the port on close.");
1599 #endif
1600 }
1601
1602 // The reader connects to readyRead() and then calls waitForReadyRead()
1603 // inside the slot.
1604 // The tst_QSerialPort::readyReadNotRecursive() test needs to make sure
1605 // that the slot is entered only once.
1606 class SemiBlockingReader : public QObject
1607 {
1608 Q_OBJECT
1609 public:
1610 explicit SemiBlockingReader(const QString &portName)
1611 : QObject(nullptr), m_portName(portName)
1612 {}
1613
1614 int numSlotCalls() const { return m_numCalls; }
1615 QByteArray receivedData() const { return m_data; }
1616
1617 public slots:
1618 void start()
1619 {
1620 m_reader = new QSerialPort(m_portName, this);
1621 connect(m_reader, &QSerialPort::readyRead, this, &SemiBlockingReader::readData);
1622 if (!m_reader->open(QIODevice::ReadOnly))
1623 emit error();
1624 }
1625
1626 private slots:
1627 void readData()
1628 {
1629 ++m_numCalls;
1630 m_data.append(m_reader->readAll());
1631 while (m_reader->waitForReadyRead(1000))
1632 m_data.append(m_reader->readAll());
1633 emit allDataReceived();
1634 }
1635
1636 signals:
1637 void error();
1638 void allDataReceived();
1639
1640 private:
1641 QString m_portName;
1642 QByteArray m_data;
1643 QSerialPort *m_reader = nullptr;
1644 int m_numCalls = 0;
1645 };
1646
1647 void tst_QSerialPort::readyReadNotRecursive()
1648 {
1649 SemiBlockingReader reader(m_receiverPortName);
1650 QThread readerThread;
1651 connect(&readerThread, &QThread::started, &reader, &SemiBlockingReader::start);
1652 connect(&reader, &SemiBlockingReader::allDataReceived, &readerThread, &QThread::quit);
1653 int errorCount = 0;
1654 connect(&reader, &SemiBlockingReader::error, this, [&] {
1655 ++errorCount;
1656 readerThread.quit();
1657 });
1658 bool readerThreadFinished = false;
1659 connect(&readerThread, &QThread::finished, this, [&] { readerThreadFinished = true; });
1660
1661 reader.moveToThread(&readerThread);
1662 readerThread.start();
1663
1664 QSerialPort senderPort(m_senderPortName);
1665 QVERIFY(senderPort.open(QSerialPort::WriteOnly));
1666 [[maybe_unused]] AsyncWriterByTimer writer(senderPort, Qt::DirectConnection,
1667 alphabetArray, 50);
1668
1669 QTRY_VERIFY(readerThreadFinished);
1670 QCOMPARE(errorCount, 0);
1671 QCOMPARE(reader.numSlotCalls(), 1);
1672 QCOMPARE(reader.receivedData(), alphabetArray);
1673 }
1674
1675 void tst_QSerialPort::writeBufferSizeLimit_data()
1676 {
1677 QTest::addColumn<qint64>("writeBufferSize");
1678
1679 QTest::newRow("NoLimit") << 0LL;
1680 QTest::newRow("8Kb") << 8 * 1024LL;
1681 }
1682
1683 void tst_QSerialPort::writeBufferSizeLimit()
1684 {
1685 QFETCH(const qint64, writeBufferSize);
1686
1687 auto setupPort = [](QSerialPort &port) {
1688 port.setBaudRate(QSerialPort::Baud115200);
1689 port.setDataBits(QSerialPort::Data8);
1690 port.setParity(QSerialPort::NoParity);
1691 port.setStopBits(QSerialPort::OneStop);
1692 };
1693
1694 QSerialPort sender(m_senderPortName);
1695 QCOMPARE_EQ(sender.writeBufferSize(), 0); // unlimited by default
1696 QSignalSpy senderSpy(&sender, &QSerialPort::bytesWritten);
1697 setupPort(sender);
1698 sender.setWriteBufferSize(writeBufferSize);
1699 QCOMPARE_EQ(sender.writeBufferSize(), writeBufferSize);
1700 QVERIFY(sender.open(QIODevice::ReadWrite));
1701
1702 QSerialPort receiver(m_receiverPortName);
1703 setupPort(receiver);
1704 QVERIFY(receiver.open(QIODevice::ReadWrite));
1705
1706 static constexpr qsizetype DataSize = 16 * 1024;
1707 QVERIFY(DataSize > writeBufferSize); // to make sure that the test works correctly
1708
1709 const QByteArray data(DataSize, 'a');
1710
1711 qint64 written = 0;
1712
1713 const bool inputBufferLimited = (writeBufferSize > 0);
1714 if (inputBufferLimited) {
1715 written = sender.write(data);
1716 QCOMPARE_EQ(written, writeBufferSize);
1717 // Writing again should return 0, as the buffer is full
1718 written = sender.write(data);
1719 QCOMPARE_EQ(written, 0); // can't add more
1720
1721 // Wait until something is actually written to the device.
1722 // NOTE: If the test fails here due to a timeout, you might
1723 // want to use QTRY_VERIFY_WITH_TIMEOUT() and a larger interval.
1724 // The behavior can depend on a OS & driver combination!
1725 QTRY_VERIFY(senderSpy.size() > 0);
1726 qint64 reportedWritten = 0;
1727 for (const auto &val : std::as_const(senderSpy))
1728 reportedWritten += val.at(0).toULongLong();
1729
1730 // Now we should be able to write at least reportedWritten bytes
1731 written = sender.write(data);
1732 QCOMPARE_GE(written, reportedWritten);
1733 } else {
1734 // Buffer is unlimited -> we should always write as much as we can
1735 written = sender.write(data);
1736 QCOMPARE_EQ(written, data.size());
1737
1738 written = sender.write(data);
1739 QCOMPARE_EQ(written, data.size());
1740
1741 // Wait until something is actually written to the device.
1742 // NOTE: If the test fails here due to a timeout, you might
1743 // want to use QTRY_VERIFY_WITH_TIMEOUT() and a larger interval.
1744 // The behavior can depend on a OS & driver combination!
1745 QTRY_VERIFY(senderSpy.size() > 0);
1746
1747 written = sender.write(data);
1748 QCOMPARE_EQ(written, data.size());
1749 }
1750
1751 receiver.close();
1752 sender.close();
1753 }
1754
1755 QTEST_MAIN(tst_QSerialPort)
1756 #include "tst_qserialport.moc"