CAN: Cleanup and modernize tests

* Adopt includes to common style
* Use member inits
* Use Qt5 connect style
* Replace QVERIFY by QCOMPARE where applicaple and vice versa
* Prettify comments
* Replace QString::fromLatin1 with QStringLiteral

Change-Id: I9d838d12062a8fa3312105f8f9110e1ba65616ee
Reviewed-by: Denis Shienkov <denis.shienkov@gmail.com>
Reviewed-by: Alex Blasche <alexander.blasche@qt.io>

3 files changed, 80 insertions, 94 deletions

diff --git a/tests/auto/qcanbus/tst_qcanbus.cpp b/tests/auto/qcanbus/tst_qcanbus.cpp
index 9e6a647..475adc4 100644
--- a/tests/auto/qcanbus/tst_qcanbus.cpp
+++ b/tests/auto/qcanbus/tst_qcanbus.cpp
@@ -37,7 +37,7 @@
 #include <QtSerialBus/qcanbus.h>
 #include <QtSerialBus/qcanbusfactory.h>
 
-#include <QtTest/QtTest>
+#include <QtTest/qtest.h>
 
 class tst_QCanBus : public QObject
 {
@@ -52,7 +52,7 @@ private slots:
     void createDevice();
 
 private:
-    QCanBus *bus;
+    QCanBus *bus = nullptr;
 };
 
 tst_QCanBus::tst_QCanBus()
@@ -89,12 +89,12 @@ void tst_QCanBus::plugins()
 void tst_QCanBus::interfaces()
 {
     // Plugins derived from QCanBusFactory(V1) don't have availableDevices()
-    const QList<QCanBusDeviceInfo> pluginListV1 = bus->availableDevices("genericV1");
-    QVERIFY(pluginListV1.isEmpty());
+    const QList<QCanBusDeviceInfo> deviceListV1 = bus->availableDevices("genericV1");
+    QVERIFY(deviceListV1.isEmpty());
 
     const QList<QCanBusDeviceInfo> pluginList = bus->availableDevices("generic");
-    QCOMPARE(1, pluginList.size());
-    QCOMPARE(QString("can0"), pluginList.at(0).name());
+    QCOMPARE(pluginList.size(), 1);
+    QCOMPARE(pluginList.at(0).name(), QStringLiteral("can0"));
     QVERIFY(pluginList.at(0).isVirtual());
     QVERIFY(pluginList.at(0).hasFlexibleDataRate());
 }
diff --git a/tests/auto/qcanbusdevice/tst_qcanbusdevice.cpp b/tests/auto/qcanbusdevice/tst_qcanbusdevice.cpp
index 3fce8d5..cf18c4a 100644
--- a/tests/auto/qcanbusdevice/tst_qcanbusdevice.cpp
+++ b/tests/auto/qcanbusdevice/tst_qcanbusdevice.cpp
@@ -34,12 +34,13 @@
 **
 ****************************************************************************/
 
-#include <QtSerialBus/QCanBusDevice>
-#include <QtSerialBus/QCanBusFrame>
+#include <QtSerialBus/qcanbusdevice.h>
+#include <QtSerialBus/qcanbusframe.h>
 
-#include <QtTest/QtTest>
-#include <QSignalSpy>
-#include <QScopedPointer>
+#include <QtCore/qscopedpointer.h>
+#include <QtCore/qtimer.h>
+#include <QtTest/qsignalspy.h>
+#include <QtTest/qtest.h>
 
 #include <memory>
 
@@ -47,8 +48,7 @@ class tst_Backend : public QCanBusDevice
 {
     Q_OBJECT
 public:
-    tst_Backend() :
-        firstOpen(true), writeBufferUsed(true)
+    tst_Backend()
     {
         referenceFrame.setFrameId(5);
         referenceFrame.setPayload(QByteArray("FOOBAR"));
@@ -61,8 +61,8 @@ public:
         if (state() != QCanBusDevice::ConnectedState)
             return false;
 
-        // line below triggers framesReceived() signal
-        enqueueReceivedFrames(QVector<QCanBusFrame>() << referenceFrame);
+        // the line below triggers the framesReceived() signal
+        enqueueReceivedFrames({referenceFrame});
 
         return true;
     }
@@ -109,7 +109,7 @@ public:
     bool isWriteBuffered() const { return writeBufferUsed; }
     void setWriteBuffered(bool isBuffered)
     {
-        // permits switching between buffered and unbuffered write mode
+        // allows switching between buffered and unbuffered write mode
         writeBufferUsed = isBuffered;
     }
 
@@ -128,8 +128,8 @@ public slots:
 
 private:
     QCanBusFrame referenceFrame;
-    bool firstOpen;
-    bool writeBufferUsed;
+    bool firstOpen = true;
+    bool writeBufferUsed = true;
 };
 
 class tst_QCanBusDevice : public QObject
@@ -165,21 +165,19 @@ void tst_QCanBusDevice::initTestCase()
     device.reset(new tst_Backend());
     QVERIFY(device);
 
-    QSignalSpy stateSpy(device.data(),
-                        SIGNAL(stateChanged(QCanBusDevice::CanBusDeviceState)));
+    QSignalSpy stateSpy(device.data(), &QCanBusDevice::stateChanged);
 
-    QVERIFY(!device->connectDevice()); //first connect triggered to fail
+    QVERIFY(!device->connectDevice()); // first connect triggered to fail
     QVERIFY(device->connectDevice());
-    QTRY_VERIFY_WITH_TIMEOUT(device->state() == QCanBusDevice::ConnectedState,
-                             5000);
+    QTRY_VERIFY_WITH_TIMEOUT(device->state() == QCanBusDevice::ConnectedState, 5000);
     QCOMPARE(stateSpy.count(), 4);
-    QCOMPARE(stateSpy[0].at(0).value<QCanBusDevice::CanBusDeviceState>(),
+    QCOMPARE(stateSpy.at(0).at(0).value<QCanBusDevice::CanBusDeviceState>(),
              QCanBusDevice::ConnectingState);
-    QCOMPARE(stateSpy[1].at(0).value<QCanBusDevice::CanBusDeviceState>(),
+    QCOMPARE(stateSpy.at(1).at(0).value<QCanBusDevice::CanBusDeviceState>(),
              QCanBusDevice::UnconnectedState);
-    QCOMPARE(stateSpy[2].at(0).value<QCanBusDevice::CanBusDeviceState>(),
+    QCOMPARE(stateSpy.at(2).at(0).value<QCanBusDevice::CanBusDeviceState>(),
              QCanBusDevice::ConnectingState);
-    QCOMPARE(stateSpy[3].at(0).value<QCanBusDevice::CanBusDeviceState>(),
+    QCOMPARE(stateSpy.at(3).at(0).value<QCanBusDevice::CanBusDeviceState>(),
              QCanBusDevice::ConnectedState);
 }
 
@@ -214,22 +212,20 @@ void tst_QCanBusDevice::write()
 {
     // we assume unbuffered writing in this function
     device->setWriteBuffered(false);
-    QCOMPARE(device->isWriteBuffered(), false);
+    QVERIFY(!device->isWriteBuffered());
 
-    QSignalSpy spy(device.data(), SIGNAL(framesWritten(qint64)));
-    QSignalSpy stateSpy(device.data(),
-                        SIGNAL(stateChanged(QCanBusDevice::CanBusDeviceState)));
+    QSignalSpy spy(device.data(), &QCanBusDevice::framesWritten);
+    QSignalSpy stateSpy(device.data(), &QCanBusDevice::stateChanged);
 
     QCanBusFrame frame;
     frame.setPayload(QByteArray("testData"));
 
     device->disconnectDevice();
-    QTRY_VERIFY_WITH_TIMEOUT(device->state() == QCanBusDevice::UnconnectedState,
-                             5000);
+    QTRY_VERIFY_WITH_TIMEOUT(device->state() == QCanBusDevice::UnconnectedState, 5000);
     QCOMPARE(stateSpy.count(), 2);
-    QCOMPARE(stateSpy[0].at(0).value<QCanBusDevice::CanBusDeviceState>(),
+    QCOMPARE(stateSpy.at(0).at(0).value<QCanBusDevice::CanBusDeviceState>(),
              QCanBusDevice::ClosingState);
-    QCOMPARE(stateSpy[1].at(0).value<QCanBusDevice::CanBusDeviceState>(),
+    QCOMPARE(stateSpy.at(1).at(0).value<QCanBusDevice::CanBusDeviceState>(),
              QCanBusDevice::UnconnectedState);
     stateSpy.clear();
     QVERIFY(stateSpy.isEmpty());
@@ -237,14 +233,12 @@ void tst_QCanBusDevice::write()
     device->writeFrame(frame);
     QCOMPARE(spy.count(), 0);
 
-
     device->connectDevice();
-    QTRY_VERIFY_WITH_TIMEOUT(device->state() == QCanBusDevice::ConnectedState,
-                             5000);
+    QTRY_VERIFY_WITH_TIMEOUT(device->state() == QCanBusDevice::ConnectedState, 5000);
     QCOMPARE(stateSpy.count(), 2);
-    QCOMPARE(stateSpy[0].at(0).value<QCanBusDevice::CanBusDeviceState>(),
+    QCOMPARE(stateSpy.at(0).at(0).value<QCanBusDevice::CanBusDeviceState>(),
              QCanBusDevice::ConnectingState);
-    QCOMPARE(stateSpy[1].at(0).value<QCanBusDevice::CanBusDeviceState>(),
+    QCOMPARE(stateSpy.at(1).at(0).value<QCanBusDevice::CanBusDeviceState>(),
              QCanBusDevice::ConnectedState);
 
     device->writeFrame(frame);
@@ -253,8 +247,7 @@ void tst_QCanBusDevice::write()
 
 void tst_QCanBusDevice::read()
 {
-    QSignalSpy stateSpy(device.data(),
-                        SIGNAL(stateChanged(QCanBusDevice::CanBusDeviceState)));
+    QSignalSpy stateSpy(device.data(), &QCanBusDevice::stateChanged);
 
     device->disconnectDevice();
     QCOMPARE(device->state(), QCanBusDevice::UnconnectedState);
@@ -263,8 +256,7 @@ void tst_QCanBusDevice::read()
     const QCanBusFrame frame1 = device->readFrame();
 
     QVERIFY(device->connectDevice());
-    QTRY_VERIFY_WITH_TIMEOUT(device->state() == QCanBusDevice::ConnectedState,
-                             5000);
+    QTRY_VERIFY_WITH_TIMEOUT(device->state() == QCanBusDevice::ConnectedState, 5000);
     QCOMPARE(stateSpy.count(), 2);
     QCOMPARE(stateSpy[0].at(0).value<QCanBusDevice::CanBusDeviceState>(),
              QCanBusDevice::ConnectingState);
@@ -281,48 +273,43 @@ void tst_QCanBusDevice::read()
 
 void tst_QCanBusDevice::error()
 {
-    QSignalSpy spy(device.data(), SIGNAL(errorOccurred(QCanBusDevice::CanBusError)));
+    QSignalSpy spy(device.data(), &QCanBusDevice::errorOccurred);
     QString testString(QStringLiteral("testString"));
 
     auto backend = qobject_cast<tst_Backend *>(device.data());
     QVERIFY(backend);
 
-    //NoError
+    // NoError
     QVERIFY(device->errorString().isEmpty());
 
-    //ReadError
-    backend->emulateError(testString+QString::fromLatin1("a"),
-                         QCanBusDevice::ReadError);
-    QCOMPARE(testString+QString::fromLatin1("a"), device->errorString());
-    QVERIFY(device->error() == 1);
+    // ReadError
+    backend->emulateError(testString + QStringLiteral("a"), QCanBusDevice::ReadError);
+    QCOMPARE(testString + QStringLiteral("a"), device->errorString());
+    QCOMPARE(device->error(), 1);
     QCOMPARE(spy.count(), 1);
 
-    //WriteError
-    backend->emulateError(testString+QString::fromLatin1("b"),
-                         QCanBusDevice::WriteError);
-    QCOMPARE(testString+QString::fromLatin1("b"), device->errorString());
-    QVERIFY(device->error() == 2);
+    // WriteError
+    backend->emulateError(testString + QStringLiteral("b"), QCanBusDevice::WriteError);
+    QCOMPARE(testString + QStringLiteral("b"), device->errorString());
+    QCOMPARE(device->error(), 2);
     QCOMPARE(spy.count(), 2);
 
-    //ConnectionError
-    backend->emulateError(testString+QString::fromLatin1("c"),
-                         QCanBusDevice::ConnectionError);
-    QCOMPARE(testString+QString::fromLatin1("c"), device->errorString());
-    QVERIFY(device->error() == 3);
+    // ConnectionError
+    backend->emulateError(testString + QStringLiteral("c"), QCanBusDevice::ConnectionError);
+    QCOMPARE(testString + QStringLiteral("c"), device->errorString());
+    QCOMPARE(device->error(), 3);
     QCOMPARE(spy.count(), 3);
 
-    //ConfigurationError
-    backend->emulateError(testString+QString::fromLatin1("d"),
-                         QCanBusDevice::ConfigurationError);
-    QCOMPARE(testString+QString::fromLatin1("d"), device->errorString());
-    QVERIFY(device->error() == 4);
+    // ConfigurationError
+    backend->emulateError(testString + QStringLiteral("d"), QCanBusDevice::ConfigurationError);
+    QCOMPARE(testString + QStringLiteral("d"), device->errorString());
+    QCOMPARE(device->error(), 4);
     QCOMPARE(spy.count(), 4);
 
-    //UnknownError
-    backend->emulateError(testString+QString::fromLatin1("e"),
-                          QCanBusDevice::UnknownError);
-    QCOMPARE(testString+QString::fromLatin1("e"), device->errorString());
-    QVERIFY(device->error() == 5);
+    // UnknownError
+    backend->emulateError(testString + QStringLiteral("e"), QCanBusDevice::UnknownError);
+    QCOMPARE(testString + QStringLiteral("e"), device->errorString());
+    QCOMPARE(device->error(), 5);
     QCOMPARE(spy.count(), 5);
 }
 
@@ -356,9 +343,8 @@ void tst_QCanBusDevice::tst_filtering()
     f.format = QCanBusDevice::Filter::MatchBaseFormat;
     filters.append(f);
 
-    QVariant wrapper = QVariant::fromValue(filters);
-    QList<QCanBusDevice::Filter> newFilter
-            = wrapper.value<QList<QCanBusDevice::Filter> >();
+    const QVariant wrapper = QVariant::fromValue(filters);
+    const auto newFilter = wrapper.value<QList<QCanBusDevice::Filter> >();
     QCOMPARE(newFilter.count(), 2);
 
     QCOMPARE(newFilter.at(0).type, QCanBusFrame::DataFrame);
@@ -380,22 +366,21 @@ void tst_QCanBusDevice::tst_filtering()
 void tst_QCanBusDevice::tst_bufferingAttribute()
 {
     std::unique_ptr<tst_Backend> canDevice(new tst_Backend);
-    QVERIFY((bool)canDevice);
+    QVERIFY(canDevice != nullptr);
     // by default buffered set to true
-    QCOMPARE(canDevice->isWriteBuffered(), true);
+    QVERIFY(canDevice->isWriteBuffered());
 
     canDevice->setWriteBuffered(false);
-    QCOMPARE(canDevice->isWriteBuffered(), false);
+    QVERIFY(!canDevice->isWriteBuffered());
     canDevice->setWriteBuffered(true);
-    QCOMPARE(canDevice->isWriteBuffered(), true);
+    QVERIFY(canDevice->isWriteBuffered());
 }
 
 void tst_QCanBusDevice::tst_waitForFramesReceived()
 {
     if (device->state() != QCanBusDevice::ConnectedState) {
         QVERIFY(device->connectDevice());
-        QTRY_VERIFY_WITH_TIMEOUT(device->state() == QCanBusDevice::ConnectedState,
-                                 5000);
+        QTRY_VERIFY_WITH_TIMEOUT(device->state() == QCanBusDevice::ConnectedState, 5000);
     }
 
     QVERIFY(!device->framesAvailable());
@@ -431,14 +416,14 @@ void tst_QCanBusDevice::tst_waitForFramesReceived()
     QVERIFY(!device->framesAvailable());
 
     QTimer::singleShot(2000, [&]() {
-        device->emulateError(QString("TriggerError"), QCanBusDevice::ReadError);
+        device->emulateError(QStringLiteral("TriggerError"), QCanBusDevice::ReadError);
     });
     elapsed.restart();
     // error will be inserted after 2s
     result = device->waitForFramesReceived(8000);
     QVERIFY(!elapsed.hasExpired(8000));
     QVERIFY(!result);
-    QCOMPARE(device->errorString(), QString("TriggerError"));
+    QCOMPARE(device->errorString(), QStringLiteral("TriggerError"));
     QCOMPARE(device->error(), QCanBusDevice::ReadError);
 
     // test recursive calling of waitForFramesReceived() behavior
@@ -450,7 +435,7 @@ void tst_QCanBusDevice::tst_waitForFramesReceived()
     QTimer::singleShot(2000, [&]() { device->triggerNewFrame(); });
     QObject::connect(device.data(), &QCanBusDevice::framesReceived, [this, &handleCounter]() {
         handleCounter++;
-        //this should trigger a recursion which we want to catch
+        // this should trigger a recursion which we want to catch
         device->waitForFramesReceived(5000);
     });
     result = device->waitForFramesReceived(8000);
@@ -462,26 +447,25 @@ void tst_QCanBusDevice::tst_waitForFramesWritten()
 {
     if (device->state() != QCanBusDevice::ConnectedState) {
         QVERIFY(device->connectDevice());
-        QTRY_VERIFY_WITH_TIMEOUT(device->state() == QCanBusDevice::ConnectedState,
-                                 5000);
+        QTRY_VERIFY_WITH_TIMEOUT(device->state() == QCanBusDevice::ConnectedState, 5000);
     }
 
     device->setWriteBuffered(false);
     bool result = device->waitForFramesWritten(1000);
-    QVERIFY(!result); //no buffer, wait not possible
+    QVERIFY(!result); // no buffer, waiting not possible
 
     device->setWriteBuffered(true);
 
     QVERIFY(device->framesToWrite() == 0);
     result = device->waitForFramesWritten(1000);
-    QVERIFY(!result); //nothing in buffer, nothing to wait for
+    QVERIFY(!result); // nothing in buffer, nothing to wait for
 
     QCanBusFrame frame;
     frame.setPayload(QByteArray("testData"));
 
     // test error case
     QTimer::singleShot(500, [&]() {
-        device->emulateError(QString("TriggerWriteError"), QCanBusDevice::ReadError);
+        device->emulateError(QStringLiteral("TriggerWriteError"), QCanBusDevice::ReadError);
     });
     device->writeFrame(frame);
     QElapsedTimer elapsed;
@@ -491,7 +475,7 @@ void tst_QCanBusDevice::tst_waitForFramesWritten()
     result = device->waitForFramesWritten(8000);
     QVERIFY(!elapsed.hasExpired(8000));
     QVERIFY(!result);
-    QCOMPARE(device->errorString(), QString("TriggerWriteError"));
+    QCOMPARE(device->errorString(), QStringLiteral("TriggerWriteError"));
     QCOMPARE(device->error(), QCanBusDevice::ReadError);
 
     // flush remaining frames out to reset the test
@@ -523,7 +507,7 @@ void tst_QCanBusDevice::tst_waitForFramesWritten()
     QTimer::singleShot(2000, [&]() { device->writeFrame(frame); });
     QObject::connect(device.data(), &QCanBusDevice::framesWritten, [this, &handleCounter]() {
         handleCounter++;
-        //this should trigger a recursion which we want to catch
+        // this should trigger a recursion which we want to catch
         device->waitForFramesWritten(5000);
     });
     result = device->waitForFramesWritten(8000);
diff --git a/tests/auto/qcanbusframe/tst_qcanbusframe.cpp b/tests/auto/qcanbusframe/tst_qcanbusframe.cpp
index 1771325..96ebee1 100644
--- a/tests/auto/qcanbusframe/tst_qcanbusframe.cpp
+++ b/tests/auto/qcanbusframe/tst_qcanbusframe.cpp
@@ -34,8 +34,10 @@
 **
 ****************************************************************************/
 
-#include <QtTest/QtTest>
-#include <QtSerialBus/QCanBusFrame>
+#include <QtSerialBus/qcanbusframe.h>
+
+#include <QtCore/qdatastream.h>
+#include <QtTest/qtest.h>
 
 class tst_QCanBusFrame : public QObject
 {
@@ -610,7 +612,7 @@ void tst_QCanBusFrame::tst_error()
     QCOMPARE(frame.frameId(), 0u); //id of Error frame always 0
     QCOMPARE(frame.error(), QCanBusFrame::TransmissionTimeoutError);
 
-    frame.setError(QCanBusFrame::FrameErrors(QCanBusFrame::ControllerError|QCanBusFrame::ProtocolViolationError));
+    frame.setError(QCanBusFrame::FrameErrors(QCanBusFrame::ControllerError | QCanBusFrame::ProtocolViolationError));
     QCOMPARE(frame.frameType(), QCanBusFrame::ErrorFrame);
     QCOMPARE(frame.frameId(), 0u); //id of Error frame always 0
     QCOMPARE(frame.error(),
@@ -618,7 +620,7 @@ void tst_QCanBusFrame::tst_error()
 
     frame.setFrameType(QCanBusFrame::RemoteRequestFrame);
     QCOMPARE(frame.frameType(), QCanBusFrame::RemoteRequestFrame);
-    QCOMPARE(frame.frameId(), (uint)(QCanBusFrame::ControllerError|QCanBusFrame::ProtocolViolationError));
+    QCOMPARE(frame.frameId(), uint(QCanBusFrame::ControllerError | QCanBusFrame::ProtocolViolationError));
     QCOMPARE(frame.error(), QCanBusFrame::NoError);
 }