Use QList instead of QVector

Task-number: QTBUG-84469
Change-Id: I3a3cd127fb9fed7b25d543a9c5af75c734397806
Reviewed-by: André Hartmann <aha_1980@gmx.de>

30 files changed, 126 insertions, 127 deletions

diff --git a/examples/serialbus/modbus/master/writeregistermodel.h b/examples/serialbus/modbus/master/writeregistermodel.h
index 4b0311e..4f29812 100644
--- a/examples/serialbus/modbus/master/writeregistermodel.h
+++ b/examples/serialbus/modbus/master/writeregistermodel.h
@@ -82,7 +82,7 @@ public:
     int m_number = 0;
     int m_address = 0;
     QBitArray m_coils;
-    QVector<quint16> m_holdingRegisters;
+    QList<quint16> m_holdingRegisters;
 };
 
 #endif // WRITEREGISTERMODEL_H
diff --git a/src/plugins/canbus/passthrucan/main.cpp b/src/plugins/canbus/passthrucan/main.cpp
index 5017597..10149af 100644
--- a/src/plugins/canbus/passthrucan/main.cpp
+++ b/src/plugins/canbus/passthrucan/main.cpp
@@ -52,7 +52,7 @@ public:
     PassThruCanBusPlugin()
     {
         qRegisterMetaType<QCanBusDevice::CanBusError>();
-        qRegisterMetaType<QVector<QCanBusFrame>>();
+        qRegisterMetaType<QList<QCanBusFrame>>();
     }
 
     QList<QCanBusDeviceInfo> availableDevices(QString *) const override
diff --git a/src/plugins/canbus/passthrucan/passthrucanbackend.h b/src/plugins/canbus/passthrucan/passthrucanbackend.h
index 864d1b4..2cbf998 100644
--- a/src/plugins/canbus/passthrucan/passthrucanbackend.h
+++ b/src/plugins/canbus/passthrucan/passthrucanbackend.h
@@ -40,9 +40,9 @@
 #include <QtSerialBus/qcanbusdevice.h>
 #include <QtSerialBus/qcanbusframe.h>
 
+#include <QList>
 #include <QString>
 #include <QThread>
-#include <QVector>
 
 QT_BEGIN_NAMESPACE
 
@@ -79,6 +79,6 @@ private:
 QT_END_NAMESPACE
 
 Q_DECLARE_METATYPE(QCanBusDevice::CanBusError)
-Q_DECLARE_METATYPE(QVector<QCanBusFrame>)
+Q_DECLARE_METATYPE(QList<QCanBusFrame>)
 
 #endif // PASSTHRUCAN_PASSTHRUCANBACKEND_H
diff --git a/src/plugins/canbus/passthrucan/passthrucanio.cpp b/src/plugins/canbus/passthrucan/passthrucanio.cpp
index dc3d2c7..43cfc21 100644
--- a/src/plugins/canbus/passthrucan/passthrucanio.cpp
+++ b/src/plugins/canbus/passthrucan/passthrucanio.cpp
@@ -287,7 +287,7 @@ void PassThruCanIO::readMessages(bool writePending)
             return;
     }
     const int numFrames = qMin<ulong>(m_ioBuffer.size(), numMsgs);
-    QVector<QCanBusFrame> frames;
+    QList<QCanBusFrame> frames;
     frames.reserve(numFrames);
 
     for (int i = 0; i < numFrames; ++i) {
diff --git a/src/plugins/canbus/passthrucan/passthrucanio.h b/src/plugins/canbus/passthrucan/passthrucanio.h
index 071174c..0ed7f42 100644
--- a/src/plugins/canbus/passthrucan/passthrucanio.h
+++ b/src/plugins/canbus/passthrucan/passthrucanio.h
@@ -48,7 +48,6 @@
 #include <QString>
 #include <QTimer>
 #include <QVariant>
-#include <QVector>
 
 QT_BEGIN_NAMESPACE
 
@@ -72,7 +71,7 @@ public:
 
 Q_SIGNALS:
     void errorOccurred(const QString &description, QCanBusDevice::CanBusError error);
-    void messagesReceived(QVector<QCanBusFrame> frames);
+    void messagesReceived(QList<QCanBusFrame> frames);
     void messagesSent(qint64 count);
     void openFinished(bool success);
     void closeFinished();
@@ -88,7 +87,7 @@ private:
     J2534::PassThru::Handle m_deviceId      = 0;
     J2534::PassThru::Handle m_channelId     = 0;
     QTimer *                m_idleNotifier  = nullptr;
-    QVector<J2534::Message> m_ioBuffer;
+    QList<J2534::Message> m_ioBuffer;
     QMutex                  m_writeGuard;
     QList<QCanBusFrame>     m_writeQueue;
 };
diff --git a/src/plugins/canbus/peakcan/peakcanbackend.cpp b/src/plugins/canbus/peakcan/peakcanbackend.cpp
index 0b4cf5b..1f9afab 100644
--- a/src/plugins/canbus/peakcan/peakcanbackend.cpp
+++ b/src/plugins/canbus/peakcan/peakcanbackend.cpp
@@ -689,7 +689,7 @@ void PeakCanBackendPrivate::startRead()
 {
     Q_Q(PeakCanBackend);
 
-    QVector<QCanBusFrame> newFrames;
+    QList<QCanBusFrame> newFrames;
 
     for (;;) {
         if (isFlexibleDatarateEnabled) {
diff --git a/src/plugins/canbus/peakcan/peakcanbackend.h b/src/plugins/canbus/peakcan/peakcanbackend.h
index 0ee74c3..df76e5c 100644
--- a/src/plugins/canbus/peakcan/peakcanbackend.h
+++ b/src/plugins/canbus/peakcan/peakcanbackend.h
@@ -38,13 +38,12 @@
 #ifndef PEAKCANBACKEND_H
 #define PEAKCANBACKEND_H
 
-#include <QtSerialBus/qcanbusframe.h>
 #include <QtSerialBus/qcanbusdevice.h>
 #include <QtSerialBus/qcanbusdeviceinfo.h>
+#include <QtSerialBus/qcanbusframe.h>
 
-#include <QtCore/qvariant.h>
-#include <QtCore/qvector.h>
 #include <QtCore/qlist.h>
+#include <QtCore/qvariant.h>
 
 QT_BEGIN_NAMESPACE
 
diff --git a/src/plugins/canbus/socketcan/socketcanbackend.cpp b/src/plugins/canbus/socketcan/socketcanbackend.cpp
index 572fef8..2470a34 100644
--- a/src/plugins/canbus/socketcan/socketcanbackend.cpp
+++ b/src/plugins/canbus/socketcan/socketcanbackend.cpp
@@ -284,7 +284,7 @@ bool SocketCanBackend::applyConfigurationParameter(int key, const QVariant &valu
             break;
         }
 
-        QVector<can_filter> filters;
+        QList<can_filter> filters;
         filters.resize(filterList.size());
         for (int i = 0; i < filterList.size(); i++) {
             const QCanBusDevice::Filter f = filterList.at(i);
@@ -457,7 +457,7 @@ void SocketCanBackend::setConfigurationParameter(int key, const QVariant &value)
 
     QCanBusDevice::setConfigurationParameter(key, value);
 
-    // we need to check CAN FD option a lot -> cache it and avoid QVector lookup
+    // we need to check CAN FD option a lot -> cache it and avoid QList lookup
     if (key == QCanBusDevice::CanFdKey)
         canFdOptionEnabled = value.toBool();
 }
@@ -685,7 +685,7 @@ QString SocketCanBackend::interpretErrorFrame(const QCanBusFrame &errorFrame)
 
 void SocketCanBackend::readSocket()
 {
-    QVector<QCanBusFrame> newFrames;
+    QList<QCanBusFrame> newFrames;
 
     for (;;) {
         m_frame = {};
diff --git a/src/plugins/canbus/systeccan/systeccanbackend.cpp b/src/plugins/canbus/systeccan/systeccanbackend.cpp
index e5bb09b..06df8e9 100644
--- a/src/plugins/canbus/systeccan/systeccanbackend.cpp
+++ b/src/plugins/canbus/systeccan/systeccanbackend.cpp
@@ -398,7 +398,7 @@ void SystecCanBackendPrivate::readAllReceivedMessages()
 {
     Q_Q(SystecCanBackend);
 
-    QVector<QCanBusFrame> newFrames;
+    QList<QCanBusFrame> newFrames;
 
     for (;;) {
         tCanMsgStruct message = {};
@@ -517,7 +517,7 @@ bool SystecCanBackend::open()
 
     // Apply all stored configurations except bitrate and receive own,
     // because these cannot be applied after opening the device
-    const QVector<int> keys = configurationKeys();
+    const QList<int> keys = configurationKeys();
     for (int key : keys) {
         if (key == BitRateKey || key == ReceiveOwnKey)
             continue;
diff --git a/src/plugins/canbus/tinycan/tinycanbackend.cpp b/src/plugins/canbus/tinycan/tinycanbackend.cpp
index 62da66d..98ffbf1 100644
--- a/src/plugins/canbus/tinycan/tinycanbackend.cpp
+++ b/src/plugins/canbus/tinycan/tinycanbackend.cpp
@@ -382,7 +382,7 @@ void TinyCanBackendPrivate::startRead()
 {
     Q_Q(TinyCanBackend);
 
-    QVector<QCanBusFrame> newFrames;
+    QList<QCanBusFrame> newFrames;
 
     for (;;) {
         if (!::CanReceiveGetCount(channelIndex))
diff --git a/src/plugins/canbus/tinycan/tinycanbackend.h b/src/plugins/canbus/tinycan/tinycanbackend.h
index 428e9bc..294778b 100644
--- a/src/plugins/canbus/tinycan/tinycanbackend.h
+++ b/src/plugins/canbus/tinycan/tinycanbackend.h
@@ -38,13 +38,12 @@
 #ifndef TINYCANBACKEND_H
 #define TINYCANBACKEND_H
 
-#include <QtSerialBus/qcanbusframe.h>
 #include <QtSerialBus/qcanbusdevice.h>
 #include <QtSerialBus/qcanbusdeviceinfo.h>
+#include <QtSerialBus/qcanbusframe.h>
 
-#include <QtCore/qvariant.h>
-#include <QtCore/qvector.h>
 #include <QtCore/qlist.h>
+#include <QtCore/qvariant.h>
 
 QT_BEGIN_NAMESPACE
 
diff --git a/src/plugins/canbus/vectorcan/vectorcanbackend.cpp b/src/plugins/canbus/vectorcan/vectorcanbackend.cpp
index 5d719d8..1e15ec8 100644
--- a/src/plugins/canbus/vectorcan/vectorcanbackend.cpp
+++ b/src/plugins/canbus/vectorcan/vectorcanbackend.cpp
@@ -399,7 +399,7 @@ void VectorCanBackendPrivate::startRead()
 {
     Q_Q(VectorCanBackend);
 
-    QVector<QCanBusFrame> newFrames;
+    QList<QCanBusFrame> newFrames;
 
     for (;;) {
         quint32 eventCount = 1;
diff --git a/src/plugins/canbus/vectorcan/vectorcanbackend.h b/src/plugins/canbus/vectorcan/vectorcanbackend.h
index 89b9da6..e90e595 100644
--- a/src/plugins/canbus/vectorcan/vectorcanbackend.h
+++ b/src/plugins/canbus/vectorcan/vectorcanbackend.h
@@ -37,13 +37,12 @@
 #ifndef VECTORCANBACKEND_H
 #define VECTORCANBACKEND_H
 
-#include <QtSerialBus/qcanbusframe.h>
 #include <QtSerialBus/qcanbusdevice.h>
 #include <QtSerialBus/qcanbusdeviceinfo.h>
+#include <QtSerialBus/qcanbusframe.h>
 
-#include <QtCore/qvariant.h>
-#include <QtCore/qvector.h>
 #include <QtCore/qlist.h>
+#include <QtCore/qvariant.h>
 
 QT_BEGIN_NAMESPACE
 
diff --git a/src/plugins/canbus/virtualcan/virtualcanbackend.h b/src/plugins/canbus/virtualcan/virtualcanbackend.h
index c83b568..38f79da 100644
--- a/src/plugins/canbus/virtualcan/virtualcanbackend.h
+++ b/src/plugins/canbus/virtualcan/virtualcanbackend.h
@@ -37,14 +37,13 @@
 #ifndef VIRTUALCANBACKEND_H
 #define VIRTUALCANBACKEND_H
 
-#include <QtSerialBus/qcanbusframe.h>
 #include <QtSerialBus/qcanbusdevice.h>
 #include <QtSerialBus/qcanbusdeviceinfo.h>
+#include <QtSerialBus/qcanbusframe.h>
 
 #include <QtCore/qlist.h>
 #include <QtCore/qurl.h>
 #include <QtCore/qvariant.h>
-#include <QtCore/qvector.h>
 
 QT_BEGIN_NAMESPACE
 
diff --git a/src/serialbus/qcanbusdevice.cpp b/src/serialbus/qcanbusdevice.cpp
index eab2a7e..537fb55 100644
--- a/src/serialbus/qcanbusdevice.cpp
+++ b/src/serialbus/qcanbusdevice.cpp
@@ -293,7 +293,7 @@ void QCanBusDevice::clearError()
     Subclasses must call this function when they receive frames.
 
 */
-void QCanBusDevice::enqueueReceivedFrames(const QVector<QCanBusFrame> &newFrames)
+void QCanBusDevice::enqueueReceivedFrames(const QList<QCanBusFrame> &newFrames)
 {
     Q_D(QCanBusDevice);
 
@@ -430,11 +430,11 @@ QVariant QCanBusDevice::configurationParameter(int key) const
     If a key is not explicitly mentioned the platform's
     default setting for the relevant key is used.
 */
-QVector<int> QCanBusDevice::configurationKeys() const
+QList<int> QCanBusDevice::configurationKeys() const
 {
     Q_D(const QCanBusDevice);
 
-    QVector<int> result;
+    QList<int> result;
     for (const ConfigEntry &e : d->configOptions)
         result.append(e.first);
 
@@ -816,13 +816,13 @@ QCanBusFrame QCanBusDevice::readFrame()
 /*!
     \since 5.12
     Returns all \l{QCanBusFrame}s from the queue; otherwise returns
-    an empty QVector. The returned frames are removed from the queue.
+    an empty QList. The returned frames are removed from the queue.
 
     The queue operates according to the FIFO principle.
 
     \sa clear(), framesAvailable(), readFrame()
 */
-QVector<QCanBusFrame> QCanBusDevice::readAllFrames()
+QList<QCanBusFrame> QCanBusDevice::readAllFrames()
 {
     Q_D(QCanBusDevice);
 
@@ -830,14 +830,14 @@ QVector<QCanBusFrame> QCanBusDevice::readAllFrames()
         const QString error = tr("Cannot read frame as device is not connected.");
         qCWarning(QT_CANBUS, "%ls", qUtf16Printable(error));
         setError(error, CanBusError::OperationError);
-        return QVector<QCanBusFrame>();
+        return QList<QCanBusFrame>();
     }
 
     clearError();
 
     QMutexLocker locker(&d->incomingFramesGuard);
 
-    QVector<QCanBusFrame> result;
+    QList<QCanBusFrame> result;
     result.swap(d->incomingFrames);
     return result;
 }
diff --git a/src/serialbus/qcanbusdevice.h b/src/serialbus/qcanbusdevice.h
index 0afd896..d8732f7 100644
--- a/src/serialbus/qcanbusdevice.h
+++ b/src/serialbus/qcanbusdevice.h
@@ -126,11 +126,11 @@ public:
 
     virtual void setConfigurationParameter(int key, const QVariant &value);
     QVariant configurationParameter(int key) const;
-    QVector<int> configurationKeys() const;
+    QList<int> configurationKeys() const;
 
     virtual bool writeFrame(const QCanBusFrame &frame) = 0;
     QCanBusFrame readFrame();
-    QVector<QCanBusFrame> readAllFrames();
+    QList<QCanBusFrame> readAllFrames();
     qint64 framesAvailable() const;
     qint64 framesToWrite() const;
 
@@ -171,7 +171,7 @@ protected:
     void setError(const QString &errorText, QCanBusDevice::CanBusError);
     void clearError();
 
-    void enqueueReceivedFrames(const QVector<QCanBusFrame> &newFrames);
+    void enqueueReceivedFrames(const QList<QCanBusFrame> &newFrames);
 
     void enqueueOutgoingFrame(const QCanBusFrame &newFrame);
     QCanBusFrame dequeueOutgoingFrame();
diff --git a/src/serialbus/qcanbusdevice_p.h b/src/serialbus/qcanbusdevice_p.h
index e74168c..3ba575b 100644
--- a/src/serialbus/qcanbusdevice_p.h
+++ b/src/serialbus/qcanbusdevice_p.h
@@ -67,10 +67,10 @@ public:
     QCanBusDevice::CanBusDeviceState state = QCanBusDevice::UnconnectedState;
     QString errorText;
 
-    QVector<QCanBusFrame> incomingFrames;
+    QList<QCanBusFrame> incomingFrames;
     QMutex incomingFramesGuard;
-    QVector<QCanBusFrame> outgoingFrames;
-    QVector<ConfigEntry> configOptions;
+    QList<QCanBusFrame> outgoingFrames;
+    QList<ConfigEntry> configOptions;
 
     bool waitForReceivedEntered = false;
     bool waitForWrittenEntered = false;
diff --git a/src/serialbus/qmodbusclient.cpp b/src/serialbus/qmodbusclient.cpp
index 56a1ab5..4c3d3de 100644
--- a/src/serialbus/qmodbusclient.cpp
+++ b/src/serialbus/qmodbusclient.cpp
@@ -302,7 +302,7 @@ QModbusRequest QModbusClientPrivate::createWriteRequest(const QModbusDataUnit &d
             byteCount += 1;
 
         quint8 address = 0;
-        QVector<quint8> bytes;
+        QList<quint8> bytes;
         for (quint8 i = 0; i < byteCount; ++i) {
             quint8 byte = 0;
             for (int currentBit = 0; currentBit < 8; ++currentBit)
@@ -501,7 +501,7 @@ bool QModbusClientPrivate::collateBytes(const QModbusPdu &response,
     if (data) {
         QDataStream stream(response.data().remove(0, 1));
 
-        QVector<quint16> values;
+        QList<quint16> values;
         const quint8 itemCount = byteCount / 2;
         for (int i = 0; i < itemCount; i++) {
             quint16 tmp;
@@ -544,7 +544,7 @@ bool QModbusClientPrivate::collateSingleValue(const QModbusPdu &response,
     if (data) {
         data->setRegisterType(type);
         data->setStartAddress(address);
-        data->setValues(QVector<quint16>{ value });
+        data->setValues(QList<quint16> { value });
     }
     return true;
 }
diff --git a/src/serialbus/qmodbusdataunit.cpp b/src/serialbus/qmodbusdataunit.cpp
index 6a07bba..9013bd7 100644
--- a/src/serialbus/qmodbusdataunit.cpp
+++ b/src/serialbus/qmodbusdataunit.cpp
@@ -98,7 +98,7 @@ QT_BEGIN_NAMESPACE
 
 /*!
     \fn QModbusDataUnit::QModbusDataUnit(RegisterType type, int address,
-                                         const QVector<quint16> &data)
+                                         const QList<quint16> &data)
 
     Constructs a unit of data for register\a type. Start address of the data is
     set to \a address and the unit's values to \a data.
@@ -138,7 +138,7 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
-    \fn void QModbusDataUnit::setValues(const QVector<quint16> &values)
+    \fn void QModbusDataUnit::setValues(const QList<quint16> &values)
 
     Sets the \a values of the data unit. \l QModbusDataUnit::DiscreteInputs
     and \l QModbusDataUnit::Coils tables only accept single bit value, so \c 0
@@ -148,7 +148,7 @@ QT_BEGIN_NAMESPACE
 */
 
 /*!
-    \fn QVector<quint16> QModbusDataUnit::values() const
+    \fn QList<quint16> QModbusDataUnit::values() const
 
     Returns the data in the data unit. \l QModbusDataUnit::DiscreteInputs
     and \l QModbusDataUnit::Coils tables only accept single bit value, so \c 0
diff --git a/src/serialbus/qmodbusdataunit.h b/src/serialbus/qmodbusdataunit.h
index fcad4ac..ca02cdb 100644
--- a/src/serialbus/qmodbusdataunit.h
+++ b/src/serialbus/qmodbusdataunit.h
@@ -37,9 +37,9 @@
 #ifndef QMODBUSDATAUNIT_H
 #define QMODBUSDATAUNIT_H
 
+#include <QtCore/qlist.h>
 #include <QtCore/qmap.h>
 #include <QtCore/qmetatype.h>
-#include <QtCore/qvector.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -61,10 +61,10 @@ public:
     {}
 
     QModbusDataUnit(RegisterType type, int newStartAddress, quint16 newValueCount)
-        : QModbusDataUnit(type, newStartAddress, QVector<quint16>(newValueCount))
+        : QModbusDataUnit(type, newStartAddress, QList<quint16>(newValueCount))
     {}
 
-    QModbusDataUnit(RegisterType type, int newStartAddress, const QVector<quint16> &newValues)
+    QModbusDataUnit(RegisterType type, int newStartAddress, const QList<quint16> &newValues)
         : m_type(type)
         , m_startAddress(newStartAddress)
         , m_values(newValues)
@@ -77,8 +77,8 @@ public:
     inline int startAddress() const { return m_startAddress; }
     inline void setStartAddress(int newAddress) { m_startAddress = newAddress; }
 
-    inline QVector<quint16> values() const { return m_values; }
-    inline void setValues(const QVector<quint16> &newValues)
+    inline QList<quint16> values() const { return m_values; }
+    inline void setValues(const QList<quint16> &newValues)
     {
         m_values = newValues;
         m_valueCount = newValues.size();
@@ -100,7 +100,7 @@ public:
 private:
     RegisterType m_type = Invalid;
     int m_startAddress = -1;
-    QVector<quint16> m_values;
+    QList<quint16> m_values;
     uint m_valueCount = 0;
 };
 typedef QMap<QModbusDataUnit::RegisterType, QModbusDataUnit> QModbusDataUnitMap;
diff --git a/src/serialbus/qmodbuspdu.h b/src/serialbus/qmodbuspdu.h
index f0542d9..c0c2117 100644
--- a/src/serialbus/qmodbuspdu.h
+++ b/src/serialbus/qmodbuspdu.h
@@ -37,8 +37,8 @@
 #define QMODBUSPDU_H
 
 #include <QtCore/qdatastream.h>
+#include <QtCore/qlist.h>
 #include <QtCore/qmetatype.h>
-#include <QtCore/qvector.h>
 #include <QtSerialBus/qtserialbusglobal.h>
 
 QT_BEGIN_NAMESPACE
@@ -154,7 +154,9 @@ private:
         static_assert(IsType<T, quint8 *, quint16 *>::value, "Only quint8* and quint16* supported.");
         (*stream) >> *t;
     }
-    template <typename T> void encode(QDataStream *stream, const QVector<T> &vector) {
+    template<typename T>
+    void encode(QDataStream *stream, const QList<T> &vector)
+    {
         static_assert(is_pod<T>::value, "Only POD types supported.");
         static_assert(IsType<T, quint8, quint16>::value, "Only quint8 and quint16 supported.");
         for (int i = 0; i < vector.count(); ++i)
diff --git a/src/serialbus/qmodbusreply.cpp b/src/serialbus/qmodbusreply.cpp
index e5561c2..e5351ae 100644
--- a/src/serialbus/qmodbusreply.cpp
+++ b/src/serialbus/qmodbusreply.cpp
@@ -53,7 +53,7 @@ public:
     QString m_errorText;
     QModbusResponse m_response;
     QModbusReply::ReplyType m_type;
-    QVector<QModbusDevice::IntermediateError> m_intermediateErrors;
+    QList<QModbusDevice::IntermediateError> m_intermediateErrors;
 };
 
 /*!
@@ -293,7 +293,7 @@ void QModbusReply::setRawResult(const QModbusResponse &response)
     the send-receive cycle of a Modbus request until the QModbusReply reports
     to be finished.
 */
-QVector<QModbusDevice::IntermediateError> QModbusReply::intermediateErrors() const
+QList<QModbusDevice::IntermediateError> QModbusReply::intermediateErrors() const
 {
     Q_D(const QModbusReply);
     return d->m_intermediateErrors;
diff --git a/src/serialbus/qmodbusreply.h b/src/serialbus/qmodbusreply.h
index 7381912..1b31995 100644
--- a/src/serialbus/qmodbusreply.h
+++ b/src/serialbus/qmodbusreply.h
@@ -37,7 +37,7 @@
 #ifndef QMODBUSREPLY_H
 #define QMODBUSREPLY_H
 
-#include <QtCore/qvector.h>
+#include <QtCore/qlist.h>
 #include <QtSerialBus/qmodbusdataunit.h>
 #include <QtSerialBus/qmodbusdevice.h>
 #include <QtSerialBus/qmodbuspdu.h>
@@ -78,7 +78,7 @@ public:
     void setFinished(bool isFinished);
     void setError(QModbusDevice::Error error, const QString &errorText);
 
-    QVector<QModbusDevice::IntermediateError> intermediateErrors() const;
+    QList<QModbusDevice::IntermediateError> intermediateErrors() const;
     void addIntermediateError(QModbusDevice::IntermediateError error);
 
 Q_SIGNALS:
diff --git a/src/serialbus/qmodbusserver.cpp b/src/serialbus/qmodbusserver.cpp
index 929ac9a..21da534 100644
--- a/src/serialbus/qmodbusserver.cpp
+++ b/src/serialbus/qmodbusserver.cpp
@@ -41,8 +41,8 @@
 
 #include <QtCore/qbitarray.h>
 #include <QtCore/qdebug.h>
+#include <QtCore/qlist.h>
 #include <QtCore/qloggingcategory.h>
-#include <QtCore/qvector.h>
 
 #include <algorithm>
 
@@ -448,7 +448,7 @@ bool QModbusServer::data(QModbusDataUnit *newData) const
 */
 bool QModbusServer::setData(QModbusDataUnit::RegisterType table, quint16 address, quint16 data)
 {
-    return writeData(QModbusDataUnit(table, address, QVector<quint16>() << data));
+    return writeData(QModbusDataUnit(table, address, QList<quint16> { data }));
 }
 
 /*!
@@ -946,7 +946,7 @@ QModbusResponse QModbusServerPrivate::processGetCommEventLogRequest(const QModbu
     }
     const quint16 deviceBusy = tmp.value<quint16>();
 
-    QVector<quint8> eventLog(int(m_commEventLog.size()));
+    QList<quint8> eventLog(int(m_commEventLog.size()));
     std::copy(m_commEventLog.cbegin(), m_commEventLog.cend(), eventLog.begin());
 
     // 6 -> 3 x 2 Bytes (Status, Event Count and Message Count)
@@ -983,7 +983,7 @@ QModbusResponse QModbusServerPrivate::processWriteMultipleCoilsRequest(const QMo
             QModbusExceptionResponse::IllegalDataAddress);
     }
 
-    QVector<quint8> bytes;
+    QList<quint8> bytes;
     const QByteArray payload = request.data().mid(5);
     for (qint32 i = payload.size() - 1; i >= 0; --i)
         bytes.append(quint8(payload[i]));
@@ -1035,7 +1035,7 @@ QModbusResponse QModbusServerPrivate::processWriteMultipleRegistersRequest(
     const QByteArray pduData = request.data().remove(0,5);
     QDataStream stream(pduData);
 
-    QVector<quint16> values;
+    QList<quint16> values;
     quint16 tmp;
     for (int i = 0; i < numberOfRegisters; i++) {
         stream >> tmp;
@@ -1134,7 +1134,7 @@ QModbusResponse QModbusServerPrivate::processReadWriteMultipleRegistersRequest(
     const QByteArray pduData = request.data().remove(0,9);
     QDataStream stream(pduData);
 
-    QVector<quint16> values;
+    QList<quint16> values;
     quint16 tmp;
     for (int i = 0; i < writeQuantity; i++) {
         stream >> tmp;
diff --git a/src/serialbus/qmodbustcpserver_p.h b/src/serialbus/qmodbustcpserver_p.h
index 3e73de3..c9f37ff 100644
--- a/src/serialbus/qmodbustcpserver_p.h
+++ b/src/serialbus/qmodbustcpserver_p.h
@@ -225,7 +225,7 @@ public:
     }
 
     QTcpServer *m_tcpServer { nullptr };
-    QVector<QTcpSocket *> connections;
+    QList<QTcpSocket *> connections;
 
     std::unique_ptr<QModbusTcpConnectionObserver> m_observer;
 
diff --git a/tests/auto/qcanbusdevice/tst_qcanbusdevice.cpp b/tests/auto/qcanbusdevice/tst_qcanbusdevice.cpp
index 61d30c0..8936531 100644
--- a/tests/auto/qcanbusdevice/tst_qcanbusdevice.cpp
+++ b/tests/auto/qcanbusdevice/tst_qcanbusdevice.cpp
@@ -210,7 +210,7 @@ void tst_QCanBusDevice::conf()
     QVariant value = device->configurationParameter(QCanBusDevice::ErrorFilterKey);
     QVERIFY(value.isValid());
 
-    QVector<int> keys = device->configurationKeys();
+    QList<int> keys = device->configurationKeys();
     QCOMPARE(keys.size(), 1);
     QVERIFY(keys.at(0) == QCanBusDevice::ErrorFilterKey);
 
@@ -294,7 +294,7 @@ void tst_QCanBusDevice::readAll()
     device->disconnectDevice();
     QTRY_VERIFY_WITH_TIMEOUT(device->state() == QCanBusDevice::UnconnectedState, 5000);
 
-    const QVector<QCanBusFrame> empty = device->readAllFrames();
+    const QList<QCanBusFrame> empty = device->readAllFrames();
     QCOMPARE(device->error(), QCanBusDevice::OperationError);
     QVERIFY(empty.isEmpty());
 
@@ -304,7 +304,7 @@ void tst_QCanBusDevice::readAll()
     for (int i = 0; i < FrameNumber; ++i)
         device->triggerNewFrame();
 
-    const QVector<QCanBusFrame> frames = device->readAllFrames();
+    const QList<QCanBusFrame> frames = device->readAllFrames();
     QCOMPARE(device->error(), QCanBusDevice::NoError);
     QCOMPARE(FrameNumber, frames.size());
     QVERIFY(!device->framesAvailable());
diff --git a/tests/auto/qmodbusclient/tst_qmodbusclient.cpp b/tests/auto/qmodbusclient/tst_qmodbusclient.cpp
index 3ffd9c3..121ea29 100644
--- a/tests/auto/qmodbusclient/tst_qmodbusclient.cpp
+++ b/tests/auto/qmodbusclient/tst_qmodbusclient.cpp
@@ -120,7 +120,7 @@ private slots:
         QCOMPARE(unit.valueCount(), 24u);
         QCOMPARE(unit.startAddress(), 100);
         QCOMPARE(unit.values(),
-            QVector<quint16>({ 1,0,1,1,0,0,1,1, 1,1,0,1,0,1,1,0, 1,0,1,0,0,0,0,0 }));
+            QList<quint16>({ 1,0,1,1,0,0,1,1, 1,1,0,1,0,1,1,0, 1,0,1,0,0,0,0,0 }));
         QCOMPARE(unit.registerType(), QModbusDataUnit::Coils);
 
         unit = QModbusDataUnit();
@@ -131,7 +131,7 @@ private slots:
         QCOMPARE(unit.isValid(), true);
         QCOMPARE(unit.valueCount(), 1u);
         QCOMPARE(unit.startAddress(), 172);
-        QCOMPARE(unit.values(), QVector<quint16>() << Coil::On);
+        QCOMPARE(unit.values(), QList<quint16>() << Coil::On);
         QCOMPARE(unit.registerType(), QModbusDataUnit::Coils);
 
         unit = QModbusDataUnit();
@@ -142,7 +142,7 @@ private slots:
         QCOMPARE(unit.isValid(), true);
         QCOMPARE(unit.valueCount(), 10u);
         QCOMPARE(unit.startAddress(), 19);
-        QCOMPARE(unit.values(), QVector<quint16>());
+        QCOMPARE(unit.values(), QList<quint16>());
         QCOMPARE(unit.registerType(), QModbusDataUnit::Coils);
     }
 
@@ -159,7 +159,7 @@ private slots:
         QCOMPARE(unit.valueCount(), 24u);
         QCOMPARE(unit.startAddress(), 100);
         QCOMPARE(unit.values(),
-            QVector<quint16>({ 1,0,1,1,0,0,1,1, 1,1,0,1,0,1,1,0, 1,0,1,0,0,0,0,0 }));
+            QList<quint16>({ 1,0,1,1,0,0,1,1, 1,1,0,1,0,1,1,0, 1,0,1,0,0,0,0,0 }));
         QCOMPARE(unit.registerType(), QModbusDataUnit::DiscreteInputs);
 
         response.setFunctionCode(QModbusPdu::FunctionCode(0x82));
@@ -189,7 +189,7 @@ private slots:
         QCOMPARE(unit.isValid(), true);
         QCOMPARE(unit.valueCount(), 2u);
         QCOMPARE(unit.startAddress(), 100);
-        QCOMPARE(unit.values(), QVector<quint16>({ 52587, 1407 }));
+        QCOMPARE(unit.values(), QList<quint16>({ 52587, 1407 }));
         QCOMPARE(unit.registerType(), QModbusDataUnit::HoldingRegisters);
 
         response.setFunctionCode(QModbusPdu::FunctionCode(0x83));
@@ -219,7 +219,7 @@ private slots:
         QCOMPARE(unit.isValid(), true);
         QCOMPARE(unit.valueCount(), 2u);
         QCOMPARE(unit.startAddress(), 100);
-        QCOMPARE(unit.values(), QVector<quint16>({ 52587, 1407 }));
+        QCOMPARE(unit.values(), QList<quint16>({ 52587, 1407 }));
         QCOMPARE(unit.registerType(), QModbusDataUnit::InputRegisters);
 
         response.setFunctionCode(QModbusPdu::FunctionCode(0x84));
@@ -248,7 +248,7 @@ private slots:
         QCOMPARE(unit.isValid(), true);
         QCOMPARE(unit.valueCount(), 1u);
         QCOMPARE(unit.startAddress(), 1229);
-        QCOMPARE(unit.values(), QVector<quint16>(1, 27397u));
+        QCOMPARE(unit.values(), QList<quint16>(1, 27397u));
         QCOMPARE(unit.registerType(), QModbusDataUnit::HoldingRegisters);
 
         response.setFunctionCode(QModbusPdu::FunctionCode(0x86));
@@ -308,7 +308,7 @@ private slots:
 
         QCOMPARE(unit.isValid(), true);
         QCOMPARE(unit.valueCount(), 2u);
-        QCOMPARE(unit.values(), QVector<quint16>({ 52587, 1407 }));
+        QCOMPARE(unit.values(), QList<quint16>({ 52587, 1407 }));
         QCOMPARE(unit.registerType(), QModbusDataUnit::HoldingRegisters);
 
         response.setFunctionCode(QModbusPdu::FunctionCode(0x97));
@@ -365,39 +365,40 @@ private slots:
     {
         QTest::addColumn<QModbusDataUnit::RegisterType>("rc");
         QTest::addColumn<int>("address");
-        QTest::addColumn<QVector<quint16>>("values");
+        QTest::addColumn<QList<quint16>>("values");
         QTest::addColumn<QModbusPdu::FunctionCode>("fc");
         QTest::addColumn<QByteArray>("data");
         QTest::addColumn<bool>("isValid");
 
-        QTest::newRow("QModbusDataUnit::Invalid") << QModbusDataUnit::Invalid << 19
-            << (QVector<quint16>() << 1) << QModbusRequest::Invalid << QByteArray() << false;
-        QTest::newRow("QModbusDataUnit::DiscreteInputs") << QModbusDataUnit::DiscreteInputs << 19
-            << (QVector<quint16>() << 1) << QModbusRequest::Invalid << QByteArray() << false;
-        QTest::newRow("QModbusDataUnit::InputRegisters") << QModbusDataUnit::InputRegisters << 19
-            << (QVector<quint16>() << 1) << QModbusRequest::Invalid << QByteArray() << false;
-
-        QTest::newRow("QModbusDataUnit::Coils{Single}") << QModbusDataUnit::Coils << 172
-            << (QVector<quint16>() << 1) << QModbusRequest::WriteSingleCoil
-            << QByteArray::fromHex("00acff00") << true;
-        QTest::newRow("QModbusDataUnit::Coils{Multiple}") << QModbusDataUnit::Coils << 19
-            << (QVector<quint16>({ 1,0,1,1,0,0,1,1, 1,0 /* 6 times padding */ }))
-            << QModbusRequest::WriteMultipleCoils << QByteArray::fromHex("0013000a02cd01")
-            << true;
+        QTest::newRow("QModbusDataUnit::Invalid") << QModbusDataUnit::Invalid << 19 << (QList<quint16> { 1 })
+                                                  << QModbusRequest::Invalid << QByteArray() << false;
+        QTest::newRow("QModbusDataUnit::DiscreteInputs")
+                << QModbusDataUnit::DiscreteInputs << 19 << (QList<quint16> { 1 }) << QModbusRequest::Invalid
+                << QByteArray() << false;
+        QTest::newRow("QModbusDataUnit::InputRegisters")
+                << QModbusDataUnit::InputRegisters << 19 << (QList<quint16> { 1 }) << QModbusRequest::Invalid
+                << QByteArray() << false;
+
+        QTest::newRow("QModbusDataUnit::Coils{Single}")
+                << QModbusDataUnit::Coils << 172 << (QList<quint16> { 1 }) << QModbusRequest::WriteSingleCoil
+                << QByteArray::fromHex("00acff00") << true;
+        QTest::newRow("QModbusDataUnit::Coils{Multiple}")
+                << QModbusDataUnit::Coils << 19
+                << (QList<quint16> { 1,0,1,1,0,0,1,1, 1,0 /* 6 times padding */ })
+                << QModbusRequest::WriteMultipleCoils << QByteArray::fromHex("0013000a02cd01") << true;
         QTest::newRow("QModbusDataUnit::HoldingRegisters{Single}")
-            << QModbusDataUnit::HoldingRegisters << 1229 << (QVector<quint16>() << 27397u)
-            << QModbusRequest::WriteSingleRegister << QByteArray::fromHex("04cd6b05") << true;
+                << QModbusDataUnit::HoldingRegisters << 1229 << (QList<quint16> { 27397u })
+                << QModbusRequest::WriteSingleRegister << QByteArray::fromHex("04cd6b05") << true;
         QTest::newRow("QModbusDataUnit::HoldingRegisters{Multiple}")
-            << QModbusDataUnit::HoldingRegisters << 1 << (QVector<quint16>() << 27397u << 27397u)
-            << QModbusRequest::WriteMultipleRegisters << QByteArray::fromHex("00010002046b056b05")
-            << true;
+                << QModbusDataUnit::HoldingRegisters << 1 << (QList<quint16> { 27397u, 27397u })
+                << QModbusRequest::WriteMultipleRegisters << QByteArray::fromHex("00010002046b056b05") << true;
     }
 
     void testPrivateCreateWriteRequest()
     {
         QFETCH(QModbusDataUnit::RegisterType, rc);
         QFETCH(int, address);
-        QFETCH(QVector<quint16>, values);
+        QFETCH(QList<quint16>, values);
 
         TestClient client;
         QModbusDataUnit write(rc, address, values);
@@ -411,30 +412,32 @@ private slots:
     {
         QTest::addColumn<QModbusDataUnit::RegisterType>("rc");
         QTest::addColumn<int>("address");
-        QTest::addColumn<QVector<quint16>>("values");
+        QTest::addColumn<QList<quint16>>("values");
         QTest::addColumn<QModbusPdu::FunctionCode>("fc");
         QTest::addColumn<QByteArray>("data");
         QTest::addColumn<bool>("isValid");
 
-        QTest::newRow("QModbusDataUnit::Invalid") << QModbusDataUnit::Invalid << 19
-            << (QVector<quint16>() << 1) << QModbusRequest::Invalid << QByteArray() << false;
-        QTest::newRow("QModbusDataUnit::Coils") << QModbusDataUnit::Invalid << 172
-            << (QVector<quint16>() << 1) << QModbusRequest::Invalid << QByteArray() << false;
-        QTest::newRow("QModbusDataUnit::DiscreteInputs") << QModbusDataUnit::DiscreteInputs << 19
-            << (QVector<quint16>() << 1) << QModbusRequest::Invalid << QByteArray() << false;
-        QTest::newRow("QModbusDataUnit::InputRegisters") << QModbusDataUnit::InputRegisters << 19
-            << (QVector<quint16>() << 1) << QModbusRequest::Invalid << QByteArray() << false;
+        QTest::newRow("QModbusDataUnit::Invalid") << QModbusDataUnit::Invalid << 19 << (QList<quint16> { 1 })
+                                                  << QModbusRequest::Invalid << QByteArray() << false;
+        QTest::newRow("QModbusDataUnit::Coils") << QModbusDataUnit::Invalid << 172 << (QList<quint16> { 1 })
+                                                << QModbusRequest::Invalid << QByteArray() << false;
+        QTest::newRow("QModbusDataUnit::DiscreteInputs")
+                << QModbusDataUnit::DiscreteInputs << 19 << (QList<quint16> { 1 }) << QModbusRequest::Invalid
+                << QByteArray() << false;
+        QTest::newRow("QModbusDataUnit::InputRegisters")
+                << QModbusDataUnit::InputRegisters << 19 << (QList<quint16> { 1 }) << QModbusRequest::Invalid
+                << QByteArray() << false;
         QTest::newRow("QModbusDataUnit::HoldingRegisters{Read|Write}")
-            << QModbusDataUnit::HoldingRegisters << 1 << (QVector<quint16>() << 27397u << 27397u)
-            << QModbusRequest::ReadWriteMultipleRegisters
-            << QByteArray::fromHex("0001000200010002046b056b05") << true;
+                << QModbusDataUnit::HoldingRegisters << 1 << (QList<quint16> { 27397u, 27397u })
+                << QModbusRequest::ReadWriteMultipleRegisters << QByteArray::fromHex("0001000200010002046b056b05")
+                << true;
     }
 
     void testPrivateCreateRWRequest()
     {
         QFETCH(QModbusDataUnit::RegisterType, rc);
         QFETCH(int, address);
-        QFETCH(QVector<quint16>, values);
+        QFETCH(QList<quint16>, values);
 
         TestClient client;
         QModbusDataUnit read(rc, address, values.count());
diff --git a/tests/auto/qmodbusdataunit/tst_qmodbusdataunit.cpp b/tests/auto/qmodbusdataunit/tst_qmodbusdataunit.cpp
index 131411c..70bb5e5 100644
--- a/tests/auto/qmodbusdataunit/tst_qmodbusdataunit.cpp
+++ b/tests/auto/qmodbusdataunit/tst_qmodbusdataunit.cpp
@@ -67,20 +67,20 @@ void tst_QModbusDataUnit::constructors()
     QCOMPARE(coils.startAddress(), 15);
     const auto values = coils.values();
     QCOMPARE(values.size(), 20);
-    QCOMPARE(values, QVector<quint16>(20));
+    QCOMPARE(values, QList<quint16>(20));
     for (auto val : values) {
         QCOMPARE(val, quint16(0));
     }
     QCOMPARE(coils.valueCount(), 20u);
 
-    QModbusDataUnit unit2(QModbusDataUnit::HoldingRegisters, 3, QVector<quint16>() << 9);
+    QModbusDataUnit unit2(QModbusDataUnit::HoldingRegisters, 3, QList<quint16> { 9 });
     QCOMPARE(unit2.registerType(), QModbusDataUnit::HoldingRegisters);
     QCOMPARE(unit2.startAddress(), 3);
     QCOMPARE(unit2.values().size(), 1);
     QCOMPARE(unit2.values().at(0), (quint16) 9);
     QCOMPARE(unit2.valueCount(), 1u);
 
-    QVector<quint16> data;
+    QList<quint16> data;
     data.append(5);
     data.append(6);
     data.append(7);
@@ -97,12 +97,12 @@ void tst_QModbusDataUnit::constructors()
 
 void tst_QModbusDataUnit::setters()
 {
-    QModbusDataUnit unit(QModbusDataUnit::HoldingRegisters, 3, QVector<quint16>() << 9);
+    QModbusDataUnit unit(QModbusDataUnit::HoldingRegisters, 3, QList<quint16> { 9 });
     QCOMPARE(unit.valueCount(), 1u);
 
     unit.setRegisterType(QModbusDataUnit::InputRegisters);
     unit.setStartAddress(2);
-    QVector<quint16> data;
+    QList<quint16> data;
     data.append(9u);
     data.append(5u);
     unit.setValues(data);
@@ -147,15 +147,15 @@ void tst_QModbusDataUnit::testAPI()
     QCOMPARE(unit.registerType(), QModbusDataUnit::Invalid);
     QCOMPARE(unit.startAddress(), -1);
     QCOMPARE(unit.valueCount(), 0u);
-    QCOMPARE(unit.values(), QVector<quint16>());
+    QCOMPARE(unit.values(), QList<quint16>());
 
     unit.setStartAddress(15);
     unit.setRegisterType(QModbusDataUnit::Coils);
     QCOMPARE(unit.isValid(), true);
 
-    QCOMPARE(unit.values(), QVector<quint16>());
-    unit.setValues(QVector<quint16> {1, 2, 3, 4});
-    QCOMPARE(unit.values(), QVector<quint16>({1, 2, 3, 4}));
+    QCOMPARE(unit.values(), QList<quint16>());
+    unit.setValues(QList<quint16> { 1, 2, 3, 4 });
+    QCOMPARE(unit.values(), QList<quint16>({ 1, 2, 3, 4 }));
 
     QCOMPARE(unit.valueCount(), 4u);
     unit.setValueCount(25);
diff --git a/tests/auto/qmodbusreply/tst_qmodbusreply.cpp b/tests/auto/qmodbusreply/tst_qmodbusreply.cpp
index 810fbee..f87784e 100644
--- a/tests/auto/qmodbusreply/tst_qmodbusreply.cpp
+++ b/tests/auto/qmodbusreply/tst_qmodbusreply.cpp
@@ -160,7 +160,7 @@ void tst_QModbusReply::tst_setResult()
     QCOMPARE(unit.valueCount(), 3u);
     QCOMPARE(unit.registerType(), QModbusDataUnit::Coils);
     QCOMPARE(unit.isValid(), true);
-    QVector<quint16>  reference = { 4,5,6 };
+    QList<quint16> reference = { 4, 5, 6 };
     QCOMPARE(unit.values(), reference);
 
     QModbusReply replyTest(QModbusReply::Common, 1);
@@ -176,7 +176,7 @@ void tst_QModbusReply::tst_setResult()
     QCOMPARE(replyTest.result().registerType(), QModbusDataUnit::Invalid);
     QCOMPARE(replyTest.result().isValid(), false);
     QCOMPARE(replyTest.rawResult().isValid(), false);
-    QCOMPARE(replyTest.result().values(), QVector<quint16>());
+    QCOMPARE(replyTest.result().values(), QList<quint16>());
 
     QModbusResponse response(QModbusResponse::ReadExceptionStatus, quint16(0x0000));
     replyTest.setResult(unit);
@@ -207,7 +207,7 @@ void tst_QModbusReply::tst_setResult()
     QCOMPARE(replyRawTest.result().registerType(), QModbusDataUnit::Invalid);
     QCOMPARE(replyRawTest.result().isValid(), false);
     QCOMPARE(replyRawTest.rawResult().isValid(), false);
-    QCOMPARE(replyRawTest.result().values(), QVector<quint16>());
+    QCOMPARE(replyRawTest.result().values(), QList<quint16>());
 
     replyRawTest.setResult(unit);
     replyRawTest.setRawResult(response);
diff --git a/tests/auto/qmodbusserver/tst_qmodbusserver.cpp b/tests/auto/qmodbusserver/tst_qmodbusserver.cpp
index ad33337..1954c7f 100644
--- a/tests/auto/qmodbusserver/tst_qmodbusserver.cpp
+++ b/tests/auto/qmodbusserver/tst_qmodbusserver.cpp
@@ -940,8 +940,8 @@ private slots:
 
         //testing server.setData(ModbusDataUnit&)
 
-        const QVector<quint16> valueVector = { 1, 1, 1, 1, 1};
-        const QVector<quint16> zeroVector = { 0, 0, 0, 0, 0};
+        const QList<quint16> valueVector = { 1, 1, 1, 1, 1 };
+        const QList<quint16> zeroVector = { 0, 0, 0, 0, 0 };
         QModbusDataUnit rangeUnit(registerType, 7, valueVector);
         QCOMPARE(rangeUnit.valueCount(), 5u);
         QCOMPARE(rangeUnit.values().count(), 5);
@@ -1085,7 +1085,7 @@ private slots:
 
         QModbusDataUnit results(QModbusDataUnit::HoldingRegisters, 3, 3);
         QVERIFY(server.data(&results));
-        QCOMPARE(results.values(), QVector<quint16>({0x1111, 0x1112, 0x1113}));
+        QCOMPARE(results.values(), QList<quint16>({ 0x1111, 0x1112, 0x1113 }));
 
         //i block write at end
         unit.setStartAddress(4);
@@ -1093,8 +1093,7 @@ private slots:
         unit.setValues({0x1, 0x2, 0x3});
         QVERIFY(server.setData(unit));
         QVERIFY(server.data(&results));
-        QCOMPARE(results.values(), QVector<quint16>({0x1, 0x2, 0x3}));
-
+        QCOMPARE(results.values(), QList<quint16>({ 0x1, 0x2, 0x3 }));
 
         unit.setStartAddress(2); // overlap in front
         QVERIFY(!server.setData(unit));