/****************************************************************************
**
** Copyright (C) 2017 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the QtSerialBus module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL3$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPLv3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or later as published by the Free
** Software Foundation and appearing in the file LICENSE.GPL included in
** the packaging of this file. Please review the following information to
** ensure the GNU General Public License version 2.0 requirements will be
** met: http://www.gnu.org/licenses/gpl-2.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include <QtCore/qdebug.h>
#include <QtSerialBus/qmodbuspdu.h>

#include <QtTest/QtTest>

static QString s_msg;
static void myMessageHandler(QtMsgType, const QMessageLogContext &, const QString &msg)
{
    s_msg = msg;
}

class DebugHandler
{
public:
    DebugHandler(QtMessageHandler newMessageHandler)
        : oldMessageHandler(qInstallMessageHandler(newMessageHandler)) {}
    ~DebugHandler() {
        qInstallMessageHandler(oldMessageHandler);
    }
private:
    QtMessageHandler oldMessageHandler;
};

static int minimumDataSize(const QModbusPdu &pdu, bool request)
{
    if (pdu.isException())
        return 1;

    switch (pdu.functionCode()) {
    case QModbusPdu::ReadCoils:
    case QModbusPdu::ReadDiscreteInputs:
        return request ? 4 : 2;
    case QModbusPdu::WriteSingleCoil:
    case QModbusPdu::WriteSingleRegister:
        return 4;
    case QModbusPdu::ReadHoldingRegisters:
    case QModbusPdu::ReadInputRegisters:
        return request ? 4 : 3;
    case QModbusPdu::ReadExceptionStatus:
        return request ? 0 : 1;
    case QModbusPdu::Diagnostics:
        return 4;
    case QModbusPdu::GetCommEventCounter:
        return request ? 0 : 4;
    case QModbusPdu::GetCommEventLog:
        return request ? 0 : 8;
    case QModbusPdu::WriteMultipleCoils:
        return request ? 6 : 4;
    case QModbusPdu::WriteMultipleRegisters:
        return request ? 7 : 4;
    case QModbusPdu::ReportServerId:
        return request ? 0 : 3;
    case QModbusPdu::ReadFileRecord:
        return request ? 8 : 5;
    case QModbusPdu::WriteFileRecord:
        return 10;
    case QModbusPdu::MaskWriteRegister:
        return 6;
    case QModbusPdu::ReadWriteMultipleRegisters:
        return request ? 11 : 3;
    case QModbusPdu::ReadFifoQueue:
        return request ? 2 : 6;
    case QModbusPdu::EncapsulatedInterfaceTransport:
        return 2;
    case QModbusPdu::Invalid:
    case QModbusPdu::UndefinedFunctionCode:
        return -1;
    }
    return -1;
}

class tst_QModbusPdu : public QObject
{
    Q_OBJECT

private slots:
    void testDefaultConstructor()
    {
        QModbusRequest request;
        QCOMPARE(request.isValid(), false);
        QCOMPARE(request.isException(), false);
        QCOMPARE(request.functionCode(), QModbusRequest::FunctionCode(0x00));
        QCOMPARE(request.exceptionCode(), QModbusPdu::ExtendedException);
        QCOMPARE(request.data().toHex(), QByteArray());

        QModbusResponse response;
        QCOMPARE(response.isValid(), false);
        QCOMPARE(response.isException(), false);
        QCOMPARE(response.functionCode(), QModbusResponse::FunctionCode(0x00));
        QCOMPARE(response.exceptionCode(), QModbusPdu::ExtendedException);
        QCOMPARE(response.data().toHex(), QByteArray());

        QModbusExceptionResponse exception;
        QCOMPARE(exception.isValid(), false);
        QCOMPARE(exception.isException(), false);
        QCOMPARE(exception.exceptionCode(), QModbusPdu::ExtendedException);
        QCOMPARE(exception.functionCode(), QModbusExceptionResponse::FunctionCode(0x00));
        QCOMPARE(exception.data().toHex(), QByteArray());
    }

    void testVaridicConstructor()
    {
        QModbusRequest request(QModbusRequest::ReportServerId);
        QCOMPARE(request.isValid(), true);
        QCOMPARE(request.isException(), false);
        QCOMPARE(request.functionCode(), QModbusRequest::ReportServerId);
        QCOMPARE(request.exceptionCode(), QModbusPdu::ExtendedException);
        QCOMPARE(request.data().toHex(), QByteArray());

        // Byte Count, Server ID, Run Indicator Status
        QModbusResponse response(QModbusResponse::ReportServerId, quint8(0x02), quint8(0x01),
            quint8(0xff));
        QCOMPARE(response.isValid(), true);
        QCOMPARE(response.isException(), false);
        QCOMPARE(response.functionCode(), QModbusResponse::ReportServerId);
        QCOMPARE(response.exceptionCode(), QModbusPdu::ExtendedException);
        QCOMPARE(response.data().toHex(), QByteArray("0201ff"));
    }

    void testQByteArrayConstructor()
    {
        QModbusRequest request(QModbusRequest::ReportServerId, QByteArray());
        QCOMPARE(request.isValid(), true);
        QCOMPARE(request.isException(), false);
        QCOMPARE(request.functionCode(), QModbusRequest::ReportServerId);
        QCOMPARE(request.data().toHex(), QByteArray());

        // Byte Count, Server ID, Run Indicator Status
        QModbusResponse response(QModbusResponse::ReportServerId, QByteArray::fromHex("ff0102"));
        QCOMPARE(response.isValid(), true);
        QCOMPARE(response.isException(), false);
        QCOMPARE(response.functionCode(), QModbusResponse::ReportServerId);
        QCOMPARE(response.data().toHex(), QByteArray("ff0102"));
    }

    void testCopyConstructorAndAssignment()
    {
        QModbusPdu pdu;
        pdu.setFunctionCode(QModbusPdu::ReadCoils);

        QModbusRequest request(pdu);
        QCOMPARE(request.functionCode(), QModbusResponse::ReadCoils);

        QModbusResponse response(pdu);
        QCOMPARE(response.functionCode(), QModbusResponse::ReadCoils);

        pdu.setFunctionCode(QModbusPdu::WriteMultipleCoils);

        request = pdu;
        QCOMPARE(request.functionCode(), QModbusResponse::WriteMultipleCoils);

        response = pdu;
        QCOMPARE(response.functionCode(), QModbusResponse::WriteMultipleCoils);
    }

    void testEncodeDecode()
    {
        QModbusRequest invalid;
        quint8 data = 0xff;
        invalid.decodeData(&data);
        QCOMPARE(data, quint8(0xff));
        invalid.encodeData(data);
        QCOMPARE(invalid.data().toHex(), QByteArray("ff"));

        data = 0x00;
        QModbusRequest request(QModbusRequest::ReportServerId);
        request.decodeData(&data);
        QCOMPARE(data, quint8(0x00));
        QCOMPARE(request.data().toHex(), QByteArray());

        QModbusResponse response(QModbusResponse::ReportServerId);
        response.encodeData(quint8(0x02), quint8(0x01), quint8(0xff));
        quint8 count = 0, id = 0, run = 0;
        response.decodeData(&count, &id, &run);
        QCOMPARE(count, quint8(0x02));
        QCOMPARE(id, quint8(0x01));
        QCOMPARE(run, quint8(0xff));
        QCOMPARE(response.data().toHex(), QByteArray("0201ff"));

        count = 0, id = 0, run = 0;
        response = QModbusResponse(QModbusResponse::ReportServerId, QByteArray::fromHex("0201ff"));
        QCOMPARE(response.isValid(), true);
        QCOMPARE(response.isException(), false);
        QCOMPARE(response.functionCode(), QModbusResponse::ReportServerId);
        QCOMPARE(response.data().toHex(), QByteArray("0201ff"));
        response.decodeData(&count, &id, &run);
        QCOMPARE(count, quint8(0x02));
        QCOMPARE(id, quint8(0x01));
        QCOMPARE(run, quint8(0xff));

        QModbusRequest readCoils(QModbusRequest::ReadCoils);
        // starting address and quantity of coils
        readCoils.encodeData(quint16(12), quint16(10));
        quint16 address, quantity;
        readCoils.decodeData(&address, &quantity);
        QCOMPARE(address, quint16(0x0c));
        QCOMPARE(quantity, quint16(0x0a));

        request = QModbusRequest(QModbusRequest::WriteMultipleCoils,
            QByteArray::fromHex("0013000a02cd01"));
        QCOMPARE(request.data().toHex(), QByteArray("0013000a02cd01"));
        address = 0xffff, quantity = 0xffff;
        quint8 bytes = 0xff, firstByte = 0xff, secondByte = 0xff;
        request.decodeData(&address, &quantity, &bytes, &firstByte, &secondByte);
        QCOMPARE(address, quint16(19));
        QCOMPARE(quantity, quint16(10));
        QCOMPARE(bytes, quint8(2));
        QCOMPARE(firstByte, quint8(0xcd));
        QCOMPARE(secondByte, quint8(0x01));
    }

    void testQModbusExceptionResponsePdu()
    {
        QModbusExceptionResponse exception(QModbusExceptionResponse::ReportServerId,
            QModbusExceptionResponse::ServerDeviceFailure);
        QCOMPARE(exception.isValid(), true);
        QCOMPARE(exception.isException(), true);
        QCOMPARE(exception.functionCode(), QModbusExceptionResponse::ReportServerId);
        QCOMPARE(exception.data().toHex(), QByteArray("04"));
        QCOMPARE(exception.exceptionCode(), QModbusExceptionResponse::ServerDeviceFailure);

        QModbusExceptionResponse response;
        QCOMPARE(response.isValid(), false);
        QCOMPARE(response.isException(), false);
        QCOMPARE(response.functionCode(), QModbusExceptionResponse::Invalid);

        response.setFunctionCode(QModbusExceptionResponse::ReportServerId);
        response.setExceptionCode(QModbusExceptionResponse::ServerDeviceFailure);
        QCOMPARE(response.isValid(), true);
        QCOMPARE(response.isException(), true);
        QCOMPARE(response.functionCode(), QModbusExceptionResponse::ReportServerId);
        QCOMPARE(response.data().toHex(), QByteArray("04"));
        QCOMPARE(exception.exceptionCode(), QModbusExceptionResponse::ServerDeviceFailure);

        QModbusPdu pdu;
        pdu.setFunctionCode(QModbusExceptionResponse::FunctionCode(QModbusPdu::ReadCoils
            | QModbusPdu::ExceptionByte));
        QCOMPARE(pdu.isException(), true);
        QCOMPARE(pdu.functionCode(), QModbusPdu::ReadCoils);

        QModbusExceptionResponse exception2(pdu);
        QCOMPARE(exception2.isException(), true);
        QCOMPARE(exception2.functionCode(), QModbusPdu::ReadCoils);
        QCOMPARE(exception2.exceptionCode(), QModbusExceptionResponse::ExtendedException);
        exception2.setExceptionCode(QModbusExceptionResponse::IllegalFunction);
        QCOMPARE(exception2.exceptionCode(), QModbusExceptionResponse::IllegalFunction);

        QModbusExceptionResponse exception3 = pdu;
        QCOMPARE(exception3.isException(), true);
        QCOMPARE(exception3.functionCode(), QModbusPdu::ReadCoils);
        QCOMPARE(exception3.exceptionCode(), QModbusExceptionResponse::ExtendedException);
    }

    void testQDebugStreamOperator()
    {
        DebugHandler mhs(myMessageHandler);
        {
            QDebug d = qDebug();
            d << QModbusPdu();
            d << QModbusRequest();
            d << QModbusResponse();
            d << QModbusExceptionResponse();
        }
        QCOMPARE(s_msg, QString::fromLatin1("0x00 0x00 0x00 0x00"));

        {
            QDebug d = qDebug();
            d << QModbusRequest(QModbusRequest::ReadCoils, quint16(19), quint16(19));
        }
        QCOMPARE(s_msg, QString::fromLatin1("0x0100130013"));

        {
            QDebug d = qDebug();
            d << QModbusResponse(QModbusResponse::ReadCoils, QByteArray::fromHex("03cd6b05"));
        }
        QCOMPARE(s_msg, QString::fromLatin1("0x0103cd6b05"));

        {
            QDebug d = qDebug();
            d << QModbusExceptionResponse(QModbusExceptionResponse::ReadCoils,
                QModbusExceptionResponse::IllegalDataAddress);
        }
        QCOMPARE(s_msg, QString::fromLatin1("0x8102"));
    }

    void testMinimumDataSize()
    {
        bool request = true;
       QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadCoils), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::ReadCoils)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadDiscreteInputs), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::ReadDiscreteInputs)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::WriteSingleCoil), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::WriteSingleCoil)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadHoldingRegisters), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::ReadHoldingRegisters)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadInputRegisters), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::ReadInputRegisters)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::WriteSingleRegister), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::WriteSingleRegister)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadExceptionStatus), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::ReadExceptionStatus)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::Diagnostics), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::Diagnostics)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::GetCommEventCounter), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::GetCommEventCounter)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::GetCommEventLog), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::GetCommEventLog)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::WriteMultipleCoils), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::WriteMultipleCoils)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::WriteMultipleRegisters), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::WriteMultipleRegisters)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReportServerId), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::ReportServerId)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadFileRecord), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::ReadFileRecord)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::WriteFileRecord), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::WriteFileRecord)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::MaskWriteRegister), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::MaskWriteRegister)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadWriteMultipleRegisters), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::ReadWriteMultipleRegisters)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadFifoQueue), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::ReadFifoQueue)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::EncapsulatedInterfaceTransport), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::EncapsulatedInterfaceTransport)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::Invalid), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::Invalid)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::UndefinedFunctionCode), request),
            QModbusRequest::minimumDataSize(QModbusRequest(QModbusRequest::Invalid)));

        request = false;
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadCoils), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::ReadCoils)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadDiscreteInputs), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::ReadDiscreteInputs)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::WriteSingleCoil), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::WriteSingleCoil)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadHoldingRegisters), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::ReadHoldingRegisters)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadInputRegisters), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::ReadInputRegisters)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::WriteSingleRegister), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::WriteSingleRegister)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadExceptionStatus), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::ReadExceptionStatus)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::Diagnostics), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::Diagnostics)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::GetCommEventCounter), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::GetCommEventCounter)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::GetCommEventLog), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::GetCommEventLog)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::WriteMultipleCoils), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::WriteMultipleCoils)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::WriteMultipleRegisters), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::WriteMultipleRegisters)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReportServerId), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::ReportServerId)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadFileRecord), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::ReadFileRecord)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::WriteFileRecord), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::WriteFileRecord)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::MaskWriteRegister), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::MaskWriteRegister)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadWriteMultipleRegisters), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::ReadWriteMultipleRegisters)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::ReadFifoQueue), request),
            QModbusResponse::minimumDataSize(QModbusResponse(QModbusResponse::ReadFifoQueue)));
        QCOMPARE(minimumDataSize(QModbusRequest(QModbusPdu::EncapsulatedInterfaceTransport), request),
            QModbusResponse::minimumDataSize(QModbusRequest(QModbusPdu::EncapsulatedInterfaceTransport)));
        QCOMPARE(minimumDataSize(QModbusResponse(QModbusPdu::Invalid), request),
            QModbusRequest::minimumDataSize(QModbusResponse(QModbusPdu::Invalid)));
        QCOMPARE(minimumDataSize(QModbusResponse(QModbusPdu::UndefinedFunctionCode), request),
            QModbusRequest::minimumDataSize(QModbusResponse(QModbusPdu::Invalid)));

        QModbusExceptionResponse exception(QModbusResponse::ReadCoils, QModbusPdu::IllegalFunction);
        QCOMPARE(minimumDataSize(exception, request), 1);
        QCOMPARE(QModbusResponse::minimumDataSize(exception), 1);
    }

    void testQModbusRequestStreamOperator_data()
    {
        QTest::addColumn<QModbusPdu::FunctionCode>("fc");
        QTest::addColumn<QByteArray>("data");
        QTest::addColumn<QByteArray>("pdu");

        QTest::newRow("ReadCoils") << QModbusRequest::ReadCoils << QByteArray::fromHex("00130013")
            << QByteArray::fromHex("0100130013");
        QTest::newRow("ReadDiscreteInputs") << QModbusRequest::ReadDiscreteInputs
            << QByteArray::fromHex("00c40016") << QByteArray::fromHex("0200c40016");
        QTest::newRow("ReadHoldingRegisters") << QModbusRequest::ReadHoldingRegisters
            << QByteArray::fromHex("006b0003") << QByteArray::fromHex("03006b0003");
        QTest::newRow("ReadInputRegisters") << QModbusRequest::ReadInputRegisters
            << QByteArray::fromHex("00080001") << QByteArray::fromHex("0400080001");
        QTest::newRow("WriteSingleCoil") << QModbusRequest::WriteSingleCoil
            << QByteArray::fromHex("00acff00") << QByteArray::fromHex("0500acff00");
        QTest::newRow("WriteSingleRegister") << QModbusRequest::WriteSingleRegister
            << QByteArray::fromHex("00010003") << QByteArray::fromHex("0600010003");
        QTest::newRow("ReadExceptionStatus") << QModbusRequest::ReadExceptionStatus
            << QByteArray() << QByteArray::fromHex("07");
        QTest::newRow("Diagnostics") << QModbusRequest::Diagnostics
            << QByteArray::fromHex("0000a537") << QByteArray::fromHex("080000a537");
        QTest::newRow("GetCommEventCounter") << QModbusRequest::GetCommEventCounter
            << QByteArray() << QByteArray::fromHex("0b");
        QTest::newRow("GetCommEventLog") << QModbusRequest::GetCommEventLog
            << QByteArray() << QByteArray::fromHex("0c");
        QTest::newRow("WriteMultipleCoils") << QModbusRequest::WriteMultipleCoils
            << QByteArray::fromHex("0013000a02cd01") << QByteArray::fromHex("0f0013000a02cd01");
        QTest::newRow("WriteMultipleRegisters") << QModbusRequest::WriteMultipleRegisters
            << QByteArray::fromHex("0001000204000a0102") << QByteArray::fromHex("100001000204000a0102");
        QTest::newRow("ReportServerId") << QModbusRequest::ReportServerId
            << QByteArray() << QByteArray::fromHex("11");
        QTest::newRow("ReadFileRecord") << QModbusRequest::ReadFileRecord
            << QByteArray::fromHex("0e0600040001000206000300090002")
            << QByteArray::fromHex("140e0600040001000206000300090002");
        QTest::newRow("WriteFileRecord") << QModbusRequest::WriteFileRecord
            << QByteArray::fromHex("0d0600040007000306af04be100d")
            << QByteArray::fromHex("150d0600040007000306af04be100d");
        QTest::newRow("MaskWriteRegister") << QModbusRequest::MaskWriteRegister
            << QByteArray::fromHex("000400f20025") << QByteArray::fromHex("16000400f20025");
        QTest::newRow("ReadWriteMultipleRegisters") << QModbusRequest::ReadWriteMultipleRegisters
            << QByteArray::fromHex("00030006000e00030600ff00ff00ff")
            << QByteArray::fromHex("1700030006000e00030600ff00ff00ff");
        QTest::newRow("ReadFifoQueue") << QModbusRequest::ReadFifoQueue
            << QByteArray::fromHex("04de") << QByteArray::fromHex("1804de");
        QTest::newRow("EncapsulatedInterfaceTransport")
            << QModbusRequest::EncapsulatedInterfaceTransport
            << QByteArray::fromHex("0e0100") << QByteArray::fromHex("2b0e0100");
    }

    void testQModbusRequestStreamOperator()
    {
        QFETCH(QModbusPdu::FunctionCode, fc);
        QFETCH(QByteArray, data);
        QFETCH(QByteArray, pdu);

        QByteArray ba;
        QDataStream output(&ba, QIODevice::WriteOnly);
        output << QModbusRequest(fc, data);
        QCOMPARE(ba, pdu);

        QModbusRequest request;
        QDataStream input(pdu);
        input >> request;
        QCOMPARE(request.functionCode(), fc);
        QCOMPARE(request.data(), data);
    }

    void testQModbusResponseStreamOperator_data()
    {
        QTest::addColumn<QModbusPdu::FunctionCode>("fc");
        QTest::addColumn<QByteArray>("data");
        QTest::addColumn<QByteArray>("pdu");

        QTest::newRow("ReadCoils") << QModbusResponse::ReadCoils << QByteArray::fromHex("03cd6b05")
            << QByteArray::fromHex("0103cd6b05");
        QTest::newRow("ReadDiscreteInputs") << QModbusResponse::ReadDiscreteInputs
            << QByteArray::fromHex("03acdb35") << QByteArray::fromHex("0203acdb35");
        QTest::newRow("ReadHoldingRegisters") << QModbusResponse::ReadHoldingRegisters
            << QByteArray::fromHex("06022b00000064") << QByteArray::fromHex("0306022b00000064");
        QTest::newRow("ReadInputRegisters") << QModbusResponse::ReadInputRegisters
            << QByteArray::fromHex("02000a") << QByteArray::fromHex("0402000a");
        QTest::newRow("WriteSingleCoil") << QModbusResponse::WriteSingleCoil
            << QByteArray::fromHex("00acff00") << QByteArray::fromHex("0500acff00");
        QTest::newRow("WriteSingleRegister") << QModbusResponse::WriteSingleRegister
            << QByteArray::fromHex("00010003") << QByteArray::fromHex("0600010003");
        QTest::newRow("ReadExceptionStatus") << QModbusResponse::ReadExceptionStatus
            << QByteArray::fromHex("6d") << QByteArray::fromHex("076d");
        QTest::newRow("Diagnostics") << QModbusResponse::Diagnostics
            << QByteArray::fromHex("ffff0108") << QByteArray::fromHex("08ffff0108");
        QTest::newRow("GetCommEventCounter") << QModbusResponse::GetCommEventCounter
            << QByteArray::fromHex("ffff0108") << QByteArray::fromHex("0bffff0108");
        QTest::newRow("GetCommEventLog") << QModbusResponse::GetCommEventLog
            << QByteArray::fromHex("080000010801212000") << QByteArray::fromHex("0c080000010801212000");
        QTest::newRow("WriteMultipleCoils") << QModbusResponse::WriteMultipleCoils
            << QByteArray::fromHex("0013000a") << QByteArray::fromHex("0f0013000a");
        QTest::newRow("WriteMultipleRegisters") << QModbusResponse::WriteMultipleRegisters
            << QByteArray::fromHex("00010002") << QByteArray::fromHex("1000010002");
        QTest::newRow("ReportServerId") << QModbusResponse::ReportServerId
            << QByteArray::fromHex("030aff12") << QByteArray::fromHex("11030aff12");
        QTest::newRow("ReadFileRecord") << QModbusResponse::ReadFileRecord
            << QByteArray::fromHex("0c05060dfe0020050633cd0040")
            << QByteArray::fromHex("140c05060dfe0020050633cd0040");
        QTest::newRow("WriteFileRecord") << QModbusResponse::WriteFileRecord
            << QByteArray::fromHex("0d0600040007000306af04be100d")
            << QByteArray::fromHex("150d0600040007000306af04be100d");
        QTest::newRow("MaskWriteRegister") << QModbusResponse::MaskWriteRegister
            << QByteArray::fromHex("000400f20025") << QByteArray::fromHex("16000400f20025");
        QTest::newRow("ReadWriteMultipleRegisters") << QModbusResponse::ReadWriteMultipleRegisters
            << QByteArray::fromHex("0c00fe0acd00010003000d00ff")
            << QByteArray::fromHex("170c00fe0acd00010003000d00ff");
        QTest::newRow("ReadFifoQueue") << QModbusResponse::ReadFifoQueue
            << QByteArray::fromHex("0006000201b81284") << QByteArray::fromHex("180006000201b81284");
        QTest::newRow("EncapsulatedInterfaceTransport")
            << QModbusResponse::EncapsulatedInterfaceTransport
            << QByteArray::fromHex("0e01010000030016") + "Company identification" +
                QByteArray::fromHex("010c") + "Product code" + QByteArray::fromHex("0205") +
                "V2.11"
            << QByteArray::fromHex("2b0e01010000030016") + "Company identification" +
                QByteArray::fromHex("010c") + "Product code" + QByteArray::fromHex("0205") +
                "V2.11";

        QModbusExceptionResponse ex(QModbusPdu::ReadCoils, QModbusPdu::IllegalDataAddress);
        QTest::newRow("StreamExceptionResponse")
            << QModbusPdu::FunctionCode(ex.functionCode() | QModbusPdu::ExceptionByte)
            << QByteArray::fromHex("02") << QByteArray::fromHex("8102");
    }

    void testQModbusResponseStreamOperator()
    {
        QFETCH(QModbusPdu::FunctionCode, fc);
        QFETCH(QByteArray, data);
        QFETCH(QByteArray, pdu);

        QByteArray ba;
        QDataStream output(&ba, QIODevice::WriteOnly);
        output << QModbusResponse(fc, data);
        QCOMPARE(ba, pdu);

        QModbusResponse response;
        QDataStream input(pdu);
        input >> response;
        if (response.isException())
            QCOMPARE(quint8(response.functionCode()), quint8(fc &~ QModbusPdu::ExceptionByte));
        else
            QCOMPARE(response.functionCode(), fc);
        QCOMPARE(response.data(), data);
    }

    void testEncapsulatedInterfaceTransportStreamOperator()
    {
        const QByteArray valid = QByteArray::fromHex("0e01010000030016") + "Company identification"
            + QByteArray::fromHex("010c") + "Product code" + QByteArray::fromHex("0205")
            + "V2.11";
        {
            QByteArray ba;
            QDataStream output(&ba, QIODevice::ReadWrite);
            output << QModbusResponse(QModbusResponse::EncapsulatedInterfaceTransport, valid);

            QModbusResponse response;
            QDataStream input(ba);
            input >> response;
            QCOMPARE(response.functionCode(), QModbusResponse::EncapsulatedInterfaceTransport);
            QCOMPARE(response.data(), valid);
        }

        // valid embedded
        const QByteArray suffix = QByteArray::fromHex("ffffffffff");
        {
            QByteArray ba;
            QDataStream output(&ba, QIODevice::ReadWrite);
            output << QModbusResponse(QModbusResponse::EncapsulatedInterfaceTransport, valid
                + suffix);

            QModbusResponse response;
            QDataStream input(ba);
            input >> response;
            QCOMPARE(response.functionCode(), QModbusResponse::EncapsulatedInterfaceTransport);
            QCOMPARE(response.data(), valid);
        }

        const QByteArray invalid = QByteArray::fromHex("0e01010000030016") + "Company identification"
            + QByteArray::fromHex("01ff") + "Product code" + QByteArray::fromHex("0205")
            + "V2.11";
        {
            QByteArray ba;
            QDataStream output(&ba, QIODevice::ReadWrite);
            output << QModbusResponse(QModbusResponse::EncapsulatedInterfaceTransport, invalid);

            QModbusResponse response;
            QDataStream input(ba);
            input >> response;
            QCOMPARE(response.functionCode(), QModbusResponse::Invalid);
            QCOMPARE(response.data(), QByteArray());
        }

        const QByteArray invalidShort = QByteArray::fromHex("0e01010000030016")
            + "Company identification" + QByteArray::fromHex("01");
        {
            QByteArray ba;
            QDataStream output(&ba, QIODevice::ReadWrite);
            output << QModbusResponse(QModbusResponse::EncapsulatedInterfaceTransport, invalidShort);

            QModbusResponse response;
            QDataStream input(ba);
            input >> response;
            QCOMPARE(response.functionCode(), QModbusResponse::Invalid);
            QCOMPARE(response.data(), QByteArray());
        }
    }

    void testCalculateDataSize()
    {
        // CanOpenGeneralReference
        QModbusResponse cogr(QModbusPdu::EncapsulatedInterfaceTransport, quint8(0x0d));
        QCOMPARE(QModbusResponse::calculateDataSize(cogr), -1);
        cogr.encodeData(quint8(0x0d), quint8(0x00));
        QCOMPARE(QModbusResponse::calculateDataSize(cogr), 2);
        // TODO: fix the following once we can calculate the size for CanOpenGeneralReference
        cogr.encodeData(quint8(0x0d), quint8(0x00), quint8(0x00));
        QCOMPARE(QModbusResponse::calculateDataSize(cogr), 2);

        // ReadDeviceIdentification
        QModbusResponse rdi(QModbusPdu::EncapsulatedInterfaceTransport, quint8(0x0e));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), -1);
        rdi.encodeData(quint8(0x0e), quint8(0x01));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 8);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 8);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 8);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 8);

        // single object
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x01)); // object count
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 8);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x01),
            quint8(0x00)); // object id
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 8);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x01),
            quint8(0x00), quint8(0x01)); // object size
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 9);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x01),
            quint8(0x00), quint8(0x01), quint8(0xff)); // object data
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 9);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x01),
            quint8(0x00), quint8(0x01), quint8(0xff),
            quint8(0xff)); // dummy additional data
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 9);

        // multiple objects equal size
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0xff), quint8(0x02),
            quint8(0x02)); // object count
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 8);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0xff), quint8(0x02),
            quint8(0x02),
            quint8(0x00)); // object id
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 8);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x02),
            quint8(0x00), quint8(0x01)); // object size
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 11);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x02),
            quint8(0x00), quint8(0x01), quint8(0xff)); // object data
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 11);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x02),
            quint8(0x00), quint8(0x01), quint8(0xff),
            quint8(0x01)); // second object id
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 11);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x02),
            quint8(0x00), quint8(0x01), quint8(0xff),
            quint8(0x01), quint8(0x01)); // second object size
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 12);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x02),
            quint8(0x00), quint8(0x01), quint8(0xff),
            quint8(0x01), quint8(0x01), quint8(0xff)); // second object data
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 12);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x02),
            quint8(0x00), quint8(0x01), quint8(0xff),
            quint8(0x01), quint8(0x01), quint8(0xff),
            quint8(0xff)); // dummy additional data
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 12);

        // multiple objects different size
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0xff), quint8(0x02),
            quint8(0x03));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 8);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0xff), quint8(0x02),
            quint8(0x03),
            quint8(0x00));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 8);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x01));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 13);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 14);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff), quint8(0xff));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 14);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff), quint8(0xff),
            quint8(0x01));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 14);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff), quint8(0xff),
            quint8(0x01), quint8(0x03));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 14);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff), quint8(0xff),
            quint8(0x01), quint8(0x03), quint8(0xff));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 14);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff), quint8(0xff),
            quint8(0x01), quint8(0x03), quint8(0xff), quint8(0xff));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 17);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff), quint8(0xff),
            quint8(0x01), quint8(0x03), quint8(0xff), quint8(0xff), quint8(0xff));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 17);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff), quint8(0xff),
            quint8(0x01), quint8(0x03), quint8(0xff), quint8(0xff), quint8(0xff),
            quint8(0x02));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 17);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff), quint8(0xff),
            quint8(0x01), quint8(0x03), quint8(0xff), quint8(0xff), quint8(0xff),
            quint8(0x02), quint8(0x05));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 22);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff), quint8(0xff),
            quint8(0x01), quint8(0x03), quint8(0xff), quint8(0xff), quint8(0xff),
            quint8(0x02), quint8(0x05), quint8(0xff));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 22);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff), quint8(0xff),
            quint8(0x01), quint8(0x03), quint8(0xff), quint8(0xff), quint8(0xff),
            quint8(0x02), quint8(0x05), quint8(0xff), quint8(0xff));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 22);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff), quint8(0xff),
            quint8(0x01), quint8(0x03), quint8(0xff), quint8(0xff), quint8(0xff),
            quint8(0x02), quint8(0x05), quint8(0xff), quint8(0xff), quint8(0xff));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 22);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff), quint8(0xff),
            quint8(0x01), quint8(0x03), quint8(0xff), quint8(0xff), quint8(0xff),
            quint8(0x02), quint8(0x05), quint8(0xff), quint8(0xff), quint8(0xff), quint8(0xff));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 22);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff), quint8(0xff),
            quint8(0x01), quint8(0x03), quint8(0xff), quint8(0xff), quint8(0xff),
            quint8(0x02), quint8(0x05), quint8(0xff), quint8(0xff), quint8(0xff), quint8(0xff), quint8(0xff));
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 22);
        rdi.encodeData(quint8(0x0e), quint8(0x01), quint8(0x01), quint8(0x00), quint8(0x00),
            quint8(0x03),
            quint8(0x00), quint8(0x02), quint8(0xff), quint8(0xff),
            quint8(0x01), quint8(0x03), quint8(0xff), quint8(0xff), quint8(0xff),
            quint8(0x02), quint8(0x05), quint8(0xff), quint8(0xff), quint8(0xff), quint8(0xff), quint8(0xff),
            quint8(0xff)); // dummy additional data
        QCOMPARE(QModbusResponse::calculateDataSize(rdi), 22);
    }

    void testCustomCalculator()
    {
        // request
        QModbusRequest request(QModbusRequest::WriteSingleCoil);
        request.encodeData(quint8(0x00), quint8(0xac), quint8(0xff), quint8(0x00));
        QCOMPARE(QModbusRequest::calculateDataSize(request), 4);

        QModbusRequest::registerDataSizeCalculator(QModbusRequest::WriteSingleCoil,
            [](const QModbusRequest &)->int {
            return 15;
        });
        QCOMPARE(QModbusRequest::calculateDataSize(request), 15);

        QModbusRequest::registerDataSizeCalculator(QModbusRequest::WriteSingleCoil, nullptr);
        QCOMPARE(QModbusRequest::calculateDataSize(request), 4);

        // response
        QModbusResponse response(QModbusRequest::WriteSingleCoil);
        response.encodeData(quint8(0x00), quint8(0xac), quint8(0xff), quint8(0x00));
        QCOMPARE(QModbusResponse::calculateDataSize(request), 4);

        QModbusResponse::registerDataSizeCalculator(QModbusResponse::WriteSingleCoil,
            [](const QModbusResponse &)->int {
            return 15;
        });
        QCOMPARE(QModbusResponse::calculateDataSize(response), 15);

        QModbusResponse::registerDataSizeCalculator(QModbusResponse::WriteSingleCoil, nullptr);
        QCOMPARE(QModbusResponse::calculateDataSize(response), 4);

        // custom
        QModbusPdu::FunctionCode custom = QModbusPdu::FunctionCode(0x30);
        request.setFunctionCode(custom);
        QCOMPARE(QModbusRequest::calculateDataSize(request), -1);

        QModbusRequest::registerDataSizeCalculator(custom, [](const QModbusRequest &)->int {
            return 27;
        });
        QCOMPARE(QModbusRequest::calculateDataSize(request), 27);
    }

    void testCalculateLongDataSize()
    {
        QByteArray longData = QByteArray(128, ' ');
        longData[0] = longData.size();
        const QModbusResponse response(QModbusResponse::ReadCoils, longData);
        QCOMPARE(QModbusResponse::calculateDataSize(response), 1 + longData.size());

        const QModbusRequest wfrRequest(QModbusPdu::WriteFileRecord, longData);
        QCOMPARE(QModbusRequest::calculateDataSize(wfrRequest), 1 + longData.size());

        longData = QByteArray(4 + 128, ' ');
        longData[4] = char(128);
        const QModbusRequest wmcRequest(QModbusPdu::WriteMultipleCoils, longData);
        QCOMPARE(QModbusRequest::calculateDataSize(wmcRequest), 1 + longData.size());

        const QModbusRequest wmrRequest(QModbusPdu::WriteMultipleRegisters, longData);
        QCOMPARE(QModbusRequest::calculateDataSize(wmrRequest), 1 + longData.size());
    }
};

QTEST_MAIN(tst_QModbusPdu)

#include "tst_qmodbuspdu.moc"