Revision control
++ // Copyright (C) 2016 Kurt Pattyn <pattyn.kurt@gmail.com>.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++ #include <QtTest/QtTest>
++ #include <QtTest/qtestcase.h>
++ #include <QtTest/QSignalSpy>
++ #include <QtCore/QBuffer>
++ #include <QtCore/QByteArray>
++ #include <QtCore/QDebug>
++
++ #include "private/qwebsocketdataprocessor_p.h"
++ #include "private/qwebsocketprotocol_p.h"
++ #include "QtWebSockets/qwebsocketprotocol.h"
++
++ const quint8 FIN = 0x80;
++ const quint8 RSV1 = 0x40;
++ const quint8 RSV2 = 0x20;
++ const quint8 RSV3 = 0x10;
++
++ QT_USE_NAMESPACE
++
++ using namespace std::chrono_literals;
++ constexpr std::chrono::milliseconds DefaultIdleTimeout = 500ms;
++
++ Q_DECLARE_METATYPE(QWebSocketProtocol::CloseCode)
++ Q_DECLARE_METATYPE(QWebSocketProtocol::OpCode)
++
++ class tst_DataProcessor : public QObject
++ {
++ Q_OBJECT
++
++ public:
++ tst_DataProcessor();
++
++ private Q_SLOTS:
++ void initTestCase();
++ void cleanupTestCase();
++ void init();
++ void cleanup();
++
++ /***************************************************************************
++ * Happy Flows
++ ***************************************************************************/
++ /*!
++ Tests all kinds of valid binary frames, including zero length frames
++ */
++ void goodBinaryFrame();
++ void goodBinaryFrame_data();
++
++ /*!
++ Tests all kinds of valid text frames, including zero length frames
++ */
++ void goodTextFrame();
++ void goodTextFrame_data();
++
++ /*!
++ * Test all kinds of valid control frames.
++ */
++ void goodControlFrame();
++
++ /*!
++ * Test all kinds of valid close frames.
++ */
++ void goodCloseFrame();
++ void goodCloseFrame_data();
++
++ /*!
++ * Test all valid opcodes
++ */
++ void goodOpcodes();
++ void goodOpcodes_data();
++
++ /*!
++ Tests the QWebSocketDataProcessor for the correct handling of non-charactercodes
++ Due to a workaround in QTextCodec, non-characters are treated as illegal.
++ This workaround is not necessary anymore, and hence code should be changed in Qt
++ to allow non-characters again.
++ */
++ void nonCharacterCodes();
++ void nonCharacterCodes_data();
++
++ /***************************************************************************
++ * Rainy Day Flows
++ ***************************************************************************/
++ /*!
++ Tests the QWebSocketDataProcessor for correct handling of frames that don't
++ contain the starting 2 bytes.
++ This test is a border case, where not enough bytes are received to even start parsing a
++ frame.
++ This test does not test sequences of frames, only single frames are tested
++ */
++ void frameTooSmall();
++
++ /*!
++ Tests the QWebSocketDataProcessor for correct handling of frames that are oversized.
++ This test does not test sequences of frames, only single frames are tested
++ */
++ void frameTooBig();
++ void frameTooBig_data();
++
++ /*!
++ Tests the QWebSocketDataProcessor for the correct handling of malformed frame headers.
++ This test does not test sequences of frames, only single frames are tested
++ */
++ void invalidHeader();
++ void invalidHeader_data();
++
++ /*!
++ Tests the QWebSocketDataProcessor for the correct handling of invalid control frames.
++ Invalid means: payload bigger than 125, frame is fragmented, ...
++ This test does not test sequences of frames, only single frames are tested
++ */
++ void invalidControlFrame();
++ void invalidControlFrame_data();
++
++ void invalidCloseFrame();
++ void invalidCloseFrame_data();
++
++ /*!
++ Tests the QWebSocketDataProcessor for the correct handling of incomplete size fields
++ for large and big payloads.
++ */
++ void incompleteSizeField();
++ void incompleteSizeField_data();
++
++ /*!
++ Tests the QWebSocketDataProcessor for the correct handling of incomplete payloads.
++ This includes:
++ - incomplete length bytes for large and big payloads (16- and 64-bit values),
++ - minimum size representation (see RFC 6455 paragraph 5.2),
++ - frames that are too large (larger than MAX_INT in bytes)
++ - incomplete payloads (less bytes than indicated in the size field)
++ This test does not test sequences of frames, only single frames are tested
++ */
++ void incompletePayload();
++ void incompletePayload_data();
++
++ /*!
++ Tests the QWebSocketDataProcessor for the correct handling of invalid UTF-8 payloads.
++ This test does not test sequences of frames, only single frames are tested
++ */
++ void invalidPayload();
++ void invalidPayload_data(bool isControlFrame = false);
++
++ void invalidPayloadInCloseFrame();
++ void invalidPayloadInCloseFrame_data();
++
++ /*!
++ Tests the QWebSocketDataProcessor for the correct handling of the minimum size representation
++ requirement of RFC 6455 (see paragraph 5.2)
++ */
++ void minimumSizeRequirement();
++ void minimumSizeRequirement_data();
++
++ void clearDataBuffers(); // qtbug-55506
++
++ /*!
++ Tests that QWebSocketDataProcessor stops handling a connection once it has
++ reported an error. RFC 6455 requires the connection to be failed on a
++ protocol violation (paragraphs 5.2 and 8.1) and forbids processing any
++ further data from the peer afterwards (paragraph 7.1.7), including bytes
++ already received (paragraph 7.1.1). The same handling is applied to frame
++ sequences that do not match the fragmentation rules of paragraph 5.4 and
++ to messages exceeding the configured limit.
++ */
++ void stopProcessingOnError();
++ void stopProcessingOnError_data();
++ void stopProcessingOnTimeout();
++
++ private:
++ //helper function that constructs a new row of test data for invalid UTF8 sequences
++ void invalidUTF8(const char *dataTag, const char *utf8Sequence, bool isCloseFrame);
++ //helper function that constructs a new row of test data for invalid leading field values
++ void invalidField(const char *dataTag, quint8 invalidFieldValue);
++ //helper functions that construct a new row of test data for size fields that do not adhere
++ //to the minimum size requirement
++ void minimumSize16Bit(quint16 sizeInBytes);
++ void minimumSize64Bit(quint64 sizeInBytes);
++ //helper function to construct a new row of test data containing frames with a payload size
++ //smaller than indicated in the header
++ void incompleteFrame(quint8 controlCode, quint64 indicatedSize, quint64 actualPayloadSize);
++ void insertIncompleteSizeFieldTest(quint8 payloadCode, quint8 numBytesFollowing);
++
++ //helper function to construct a new row of test data containing text frames containing
++ //sequences
++ void nonCharacterSequence(const char *sequence);
++
++ void doTest(int timeout = 0);
++ void doCloseFrameTest();
++
++ QString opCodeToString(quint8 opCode);
++ };
++
++ tst_DataProcessor::tst_DataProcessor()
++ {
++ }
++
++ void tst_DataProcessor::initTestCase()
++ {
++ }
++
++ void tst_DataProcessor::cleanupTestCase()
++ {
++ }
++
++ void tst_DataProcessor::init()
++ {
++ qRegisterMetaType<QWebSocketProtocol::OpCode>("QWebSocketProtocol::OpCode");
++ qRegisterMetaType<QWebSocketProtocol::CloseCode>("QWebSocketProtocol::CloseCode");
++ }
++
++ void tst_DataProcessor::cleanup()
++ {
++ }
++
++ void tst_DataProcessor::goodBinaryFrame_data()
++ {
++ QTest::addColumn<QByteArray>("payload");
++ //be sure to get small (< 126 bytes), large (> 125 bytes & < 64K) and big (>64K) frames
++ for (int i = 0; i < (65536 + 256); i += 128)
++ {
++ QTest::newRow(QStringLiteral("Binary frame with %1 bytes").arg(i).toLatin1().constData())
++ << QByteArray(i, char(1));
++ }
++ for (int i = 0; i < 256; ++i) //test all possible bytes in the payload
++ {
++ QTest::newRow(QStringLiteral("Binary frame containing byte: '0x%1'")
++ .arg(QByteArray(1, char(i)).toHex().constData()).toLatin1().constData())
++ << QByteArray(i, char(1));
++ }
++ }
++
++ void tst_DataProcessor::goodBinaryFrame()
++ {
++ QByteArray data;
++ QBuffer buffer;
++ QWebSocketDataProcessor dataProcessor;
++ QFETCH(QByteArray, payload);
++
++ data.append(char(FIN | QWebSocketProtocol::OpCodeBinary));
++
++ if (payload.size() < 126)
++ {
++ data.append(char(payload.size()));
++ }
++ else if (payload.size() < 65536)
++ {
++ quint16 swapped = qToBigEndian<quint16>(payload.size());
++ const char *wireRepresentation
++ = static_cast<const char *>(static_cast<const void *>(&swapped));
++ data.append(char(126)).append(wireRepresentation, 2);
++ }
++ else
++ {
++ quint64 swapped = qToBigEndian<quint64>(payload.size());
++ const char *wireRepresentation
++ = static_cast<const char *>(static_cast<const void *>(&swapped));
++ data.append(char(127)).append(wireRepresentation, 8);
++ }
++
++ data.append(payload);
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++
++ QSignalSpy errorReceivedSpy(&dataProcessor,
++ SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy closeReceivedSpy(&dataProcessor,
++ SIGNAL(closeReceived(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy pingReceivedSpy(&dataProcessor, SIGNAL(pingReceived(QByteArray)));
++ QSignalSpy pongReceivedSpy(&dataProcessor, SIGNAL(pongReceived(QByteArray)));
++ QSignalSpy binaryFrameReceivedSpy(&dataProcessor, SIGNAL(binaryFrameReceived(QByteArray,bool)));
++ QSignalSpy binaryMessageReceivedSpy(&dataProcessor, SIGNAL(binaryMessageReceived(QByteArray)));
++ QSignalSpy textFrameReceivedSpy(&dataProcessor, SIGNAL(textFrameReceived(QString,bool)));
++ QSignalSpy textMessageReceivedSpy(&dataProcessor, SIGNAL(textMessageReceived(QString)));
++ dataProcessor.process(&buffer);
++ QCOMPARE(errorReceivedSpy.size(), 0);
++ QCOMPARE(pingReceivedSpy.size(), 0);
++ QCOMPARE(pongReceivedSpy.size(), 0);
++ QCOMPARE(closeReceivedSpy.size(), 0);
++ QCOMPARE(binaryFrameReceivedSpy.size(), 1);
++ QCOMPARE(binaryMessageReceivedSpy.size(), 1);
++ QCOMPARE(textFrameReceivedSpy.size(), 0);
++ QCOMPARE(textMessageReceivedSpy.size(), 0);
++ QList<QVariant> arguments = binaryFrameReceivedSpy.takeFirst();
++ QCOMPARE(arguments.at(0).toByteArray().size(), payload.size());
++ arguments = binaryMessageReceivedSpy.takeFirst();
++ QCOMPARE(arguments.at(0).toByteArray().size(), payload.size());
++ buffer.close();
++ }
++
++ void tst_DataProcessor::goodTextFrame_data()
++ {
++ QTest::addColumn<QByteArray>("payload");
++ QTest::addColumn<int>("size");
++
++ //test frames with small (< 126), large ( < 65536) and big ( > 65535) payloads
++ for (int i = 0; i < (65536 + 256); i += 128)
++ {
++ QTest::newRow(QStringLiteral("Text frame with %1 ASCII characters")
++ .arg(i).toLatin1().constData()) << QByteArray(i, 'a') << i;
++ }
++ //test all valid ASCII characters
++ for (int i = 0; i < 128; ++i)
++ {
++ QTest::newRow(QStringLiteral("Text frame with containing ASCII character '0x%1'")
++ .arg(QByteArray(1, char(i)).toHex().constData()).toLatin1().constData())
++ << QByteArray(1, char(i)) << 1;
++ }
++
++ //the text string reads: Text frame containing Hello-µ@ßöäüà á-UTF-8!!
++ //Visual Studio doesn't like UTF-8 in source code, so we use escape codes for the string
++ //The number 22 refers to the length of the string;
++ //the length was incorrectly calculated on Visual Studio
++
++ //doing extensive QStringLiteral concatenations here, because
++ //MSVC 2010 complains when using concatenation literal strings about
++ //concatenation of wide and narrow strings:
++ //error C2308: concatenating mismatched strings
++ QTest::newRow((QStringLiteral("Text frame containing Hello-") +
++ QStringLiteral("\xC2\xB5\x40\xC3\x9F\xC3\xB6\xC3\xA4\xC3\xBC\xC3\xA0") +
++ QStringLiteral("\xC3\xA1-UTF-8!!")).toUtf8().constData())
++ << QByteArray::fromHex("48656c6c6f2dc2b540c39fc3b6c3a4c3bcc3a0c3a12d5554462d382121")
++ << 22;
++ }
++
++ void tst_DataProcessor::goodTextFrame()
++ {
++ QByteArray data;
++ QBuffer buffer;
++ QWebSocketDataProcessor dataProcessor;
++ QFETCH(QByteArray, payload);
++ QFETCH(int, size);
++
++ data.append(char(FIN | QWebSocketProtocol::OpCodeText));
++
++ if (payload.size() < 126)
++ {
++ data.append(char(payload.size()));
++ }
++ else if (payload.size() < 65536)
++ {
++ quint16 swapped = qToBigEndian<quint16>(payload.size());
++ const char *wireRepresentation
++ = static_cast<const char *>(static_cast<const void *>(&swapped));
++ data.append(char(126)).append(wireRepresentation, 2);
++ }
++ else
++ {
++ quint64 swapped = qToBigEndian<quint64>(payload.size());
++ const char *wireRepresentation
++ = static_cast<const char *>(static_cast<const void *>(&swapped));
++ data.append(char(127)).append(wireRepresentation, 8);
++ }
++
++ data.append(payload);
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++
++ QSignalSpy errorReceivedSpy(&dataProcessor,
++ SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy closeReceivedSpy(&dataProcessor,
++ SIGNAL(closeReceived(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy pingReceivedSpy(&dataProcessor, SIGNAL(pingReceived(QByteArray)));
++ QSignalSpy pongReceivedSpy(&dataProcessor, SIGNAL(pongReceived(QByteArray)));
++ QSignalSpy textFrameReceivedSpy(&dataProcessor, SIGNAL(textFrameReceived(QString,bool)));
++ QSignalSpy textMessageReceivedSpy(&dataProcessor, SIGNAL(textMessageReceived(QString)));
++ QSignalSpy binaryFrameReceivedSpy(&dataProcessor, SIGNAL(binaryFrameReceived(QByteArray,bool)));
++ QSignalSpy binaryMessageReceivedSpy(&dataProcessor, SIGNAL(binaryMessageReceived(QByteArray)));
++
++ dataProcessor.process(&buffer);
++
++ QCOMPARE(errorReceivedSpy.size(), 0);
++ QCOMPARE(pingReceivedSpy.size(), 0);
++ QCOMPARE(pongReceivedSpy.size(), 0);
++ QCOMPARE(closeReceivedSpy.size(), 0);
++ QCOMPARE(textFrameReceivedSpy.size(), 1);
++ QCOMPARE(textMessageReceivedSpy.size(), 1);
++ QCOMPARE(binaryFrameReceivedSpy.size(), 0);
++ QCOMPARE(binaryMessageReceivedSpy.size(), 0);
++ QList<QVariant> arguments = textFrameReceivedSpy.takeFirst();
++ QCOMPARE(arguments.at(0).toString().size(), size);
++ arguments = textMessageReceivedSpy.takeFirst();
++ QCOMPARE(arguments.at(0).toString().size(), size);
++ buffer.close();
++ }
++
++ void tst_DataProcessor::goodControlFrame()
++ {
++ QByteArray data;
++ QBuffer buffer;
++ QWebSocketDataProcessor dataProcessor;
++
++ QSignalSpy closeFrameReceivedSpy(&dataProcessor,
++ SIGNAL(closeReceived(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy errorReceivedSpy(&dataProcessor,
++ SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy textFrameReceivedSpy(&dataProcessor, SIGNAL(textFrameReceived(QString,bool)));
++ QSignalSpy textMessageReceivedSpy(&dataProcessor, SIGNAL(textMessageReceived(QString)));
++ QSignalSpy binaryFrameReceivedSpy(&dataProcessor, SIGNAL(binaryFrameReceived(QByteArray,bool)));
++ QSignalSpy binaryMessageReceivedSpy(&dataProcessor, SIGNAL(binaryMessageReceived(QByteArray)));
++ QSignalSpy pingReceivedSpy(&dataProcessor, SIGNAL(pingReceived(QByteArray)));
++ QSignalSpy pongReceivedSpy(&dataProcessor, SIGNAL(pongReceived(QByteArray)));
++
++ data.append(char(FIN | QWebSocketProtocol::OpCodePing));
++ data.append('\0');
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++ dataProcessor.process(&buffer);
++ QCOMPARE(errorReceivedSpy.size(), 0);
++ QCOMPARE(textFrameReceivedSpy.size(), 0);
++ QCOMPARE(textMessageReceivedSpy.size(), 0);
++ QCOMPARE(binaryFrameReceivedSpy.size(), 0);
++ QCOMPARE(binaryMessageReceivedSpy.size(), 0);
++ QCOMPARE(closeFrameReceivedSpy.size(), 0);
++ QCOMPARE(pongReceivedSpy.size(), 0);
++ QCOMPARE(pingReceivedSpy.size(), 1);
++ buffer.close();
++
++ data.clear();
++ pingReceivedSpy.clear();
++ pongReceivedSpy.clear();
++ data.append(char(FIN | QWebSocketProtocol::OpCodePong));
++ data.append('\0');
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++ dataProcessor.process(&buffer);
++ QCOMPARE(errorReceivedSpy.size(), 0);
++ QCOMPARE(textFrameReceivedSpy.size(), 0);
++ QCOMPARE(textMessageReceivedSpy.size(), 0);
++ QCOMPARE(binaryFrameReceivedSpy.size(), 0);
++ QCOMPARE(binaryMessageReceivedSpy.size(), 0);
++ QCOMPARE(closeFrameReceivedSpy.size(), 0);
++ QCOMPARE(pingReceivedSpy.size(), 0);
++ QCOMPARE(pongReceivedSpy.size(), 1);
++ buffer.close();
++ }
++
++ void tst_DataProcessor::goodCloseFrame_data()
++ {
++ QTest::addColumn<QString>("payload");
++ QTest::addColumn<QWebSocketProtocol::CloseCode>("closeCode");
++ //control frame data cannot exceed 125 bytes; smaller than 124,
++ //because we also need a 2 byte close code
++ for (int i = 0; i < 124; ++i)
++ {
++ QTest::newRow(QStringLiteral("Close frame with %1 ASCII characters")
++ .arg(i).toLatin1().constData())
++ << QString(i, 'a')
++ << QWebSocketProtocol::CloseCodeNormal;
++ }
++ for (int i = 0; i < 126; ++i)
++ {
++ QTest::newRow(QStringLiteral("Text frame with containing ASCII character '0x%1'")
++ .arg(QByteArray(1, char(i)).toHex().constData()).toLatin1().constData())
++ << QString(1, char(i)) << QWebSocketProtocol::CloseCodeNormal;
++ }
++ QTest::newRow("Close frame with close code NORMAL")
++ << QString(1, 'a') << QWebSocketProtocol::CloseCodeNormal;
++ QTest::newRow("Close frame with close code BAD OPERATION")
++ << QString(1, 'a') << QWebSocketProtocol::CloseCodeBadOperation;
++ QTest::newRow("Close frame with close code DATATYPE NOT SUPPORTED")
++ << QString(1, 'a') << QWebSocketProtocol::CloseCodeDatatypeNotSupported;
++ QTest::newRow("Close frame with close code GOING AWAY")
++ << QString(1, 'a') << QWebSocketProtocol::CloseCodeGoingAway;
++ QTest::newRow("Close frame with close code MISSING EXTENSION")
++ << QString(1, 'a') << QWebSocketProtocol::CloseCodeMissingExtension;
++ QTest::newRow("Close frame with close code POLICY VIOLATED")
++ << QString(1, 'a') << QWebSocketProtocol::CloseCodePolicyViolated;
++ QTest::newRow("Close frame with close code PROTOCOL ERROR")
++ << QString(1, 'a') << QWebSocketProtocol::CloseCodeProtocolError;
++ QTest::newRow("Close frame with close code TOO MUCH DATA")
++ << QString(1, 'a') << QWebSocketProtocol::CloseCodeTooMuchData;
++ QTest::newRow("Close frame with close code WRONG DATATYPE")
++ << QString(1, 'a') << QWebSocketProtocol::CloseCodeWrongDatatype;
++ QTest::newRow("Close frame with close code 3000")
++ << QString(1, 'a') << QWebSocketProtocol::CloseCode(3000);
++ QTest::newRow("Close frame with close code 3999")
++ << QString(1, 'a') << QWebSocketProtocol::CloseCode(3999);
++ QTest::newRow("Close frame with close code 4000")
++ << QString(1, 'a') << QWebSocketProtocol::CloseCode(4000);
++ QTest::newRow("Close frame with close code 4999")
++ << QString(1, 'a') << QWebSocketProtocol::CloseCode(4999);
++
++ //close frames with no close reason
++ QTest::newRow("Close frame with close code NORMAL and no reason")
++ << QString() << QWebSocketProtocol::CloseCodeNormal;
++ QTest::newRow("Close frame with close code BAD OPERATION and no reason")
++ << QString() << QWebSocketProtocol::CloseCodeBadOperation;
++ QTest::newRow("Close frame with close code DATATYPE NOT SUPPORTED and no reason")
++ << QString() << QWebSocketProtocol::CloseCodeDatatypeNotSupported;
++ QTest::newRow("Close frame with close code GOING AWAY and no reason")
++ << QString() << QWebSocketProtocol::CloseCodeGoingAway;
++ QTest::newRow("Close frame with close code MISSING EXTENSION and no reason")
++ << QString() << QWebSocketProtocol::CloseCodeMissingExtension;
++ QTest::newRow("Close frame with close code POLICY VIOLATED and no reason")
++ << QString() << QWebSocketProtocol::CloseCodePolicyViolated;
++ QTest::newRow("Close frame with close code PROTOCOL ERROR and no reason")
++ << QString() << QWebSocketProtocol::CloseCodeProtocolError;
++ QTest::newRow("Close frame with close code TOO MUCH DATA and no reason")
++ << QString() << QWebSocketProtocol::CloseCodeTooMuchData;
++ QTest::newRow("Close frame with close code WRONG DATATYPE and no reason")
++ << QString() << QWebSocketProtocol::CloseCodeWrongDatatype;
++ QTest::newRow("Close frame with close code 3000 and no reason")
++ << QString() << QWebSocketProtocol::CloseCode(3000);
++ QTest::newRow("Close frame with close code 3999 and no reason")
++ << QString() << QWebSocketProtocol::CloseCode(3999);
++ QTest::newRow("Close frame with close code 4000 and no reason")
++ << QString() << QWebSocketProtocol::CloseCode(4000);
++ QTest::newRow("Close frame with close code 4999 and no reason")
++ << QString() << QWebSocketProtocol::CloseCode(4999);
++
++ QTest::newRow("Close frame with no close code and no reason")
++ << QString() << QWebSocketProtocol::CloseCode(0);
++ }
++
++ void tst_DataProcessor::goodOpcodes_data()
++ {
++ QTest::addColumn<QWebSocketProtocol::OpCode>("opCode");
++
++ QTest::newRow("Frame with PING opcode") << QWebSocketProtocol::OpCodePing;
++ QTest::newRow("Frame with PONG opcode") << QWebSocketProtocol::OpCodePong;
++ QTest::newRow("Frame with TEXT opcode") << QWebSocketProtocol::OpCodeText;
++ QTest::newRow("Frame with BINARY opcode") << QWebSocketProtocol::OpCodeBinary;
++ QTest::newRow("Frame with CLOSE opcode") << QWebSocketProtocol::OpCodeClose;
++ }
++
++ void tst_DataProcessor::goodOpcodes()
++ {
++ QByteArray data;
++ QBuffer buffer;
++ QWebSocketDataProcessor dataProcessor;
++ QFETCH(QWebSocketProtocol::OpCode, opCode);
++
++ data.append(char(FIN | opCode));
++ data.append(char(0)); //zero length
++
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++
++ QSignalSpy errorReceivedSpy(&dataProcessor,
++ SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy closeReceivedSpy(&dataProcessor,
++ SIGNAL(closeReceived(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy pingReceivedSpy(&dataProcessor,
++ SIGNAL(pingReceived(QByteArray)));
++ QSignalSpy pongReceivedSpy(&dataProcessor,
++ SIGNAL(pongReceived(QByteArray)));
++ QSignalSpy textFrameReceivedSpy(&dataProcessor,
++ SIGNAL(textFrameReceived(QString,bool)));
++ QSignalSpy textMessageReceivedSpy(&dataProcessor,
++ SIGNAL(textMessageReceived(QString)));
++ QSignalSpy binaryFrameReceivedSpy(&dataProcessor,
++ SIGNAL(binaryFrameReceived(QByteArray,bool)));
++ QSignalSpy binaryMessageReceivedSpy(&dataProcessor,
++ SIGNAL(binaryMessageReceived(QByteArray)));
++
++ dataProcessor.process(&buffer);
++
++ QCOMPARE(errorReceivedSpy.size(), 0);
++ QCOMPARE(pingReceivedSpy.size(), opCode == QWebSocketProtocol::OpCodePing ? 1 : 0);
++ QCOMPARE(pongReceivedSpy.size(), opCode == QWebSocketProtocol::OpCodePong ? 1 : 0);
++ QCOMPARE(closeReceivedSpy.size(), opCode == QWebSocketProtocol::OpCodeClose ? 1 : 0);
++ QCOMPARE(textFrameReceivedSpy.size(), opCode == QWebSocketProtocol::OpCodeText ? 1 : 0);
++ QCOMPARE(textMessageReceivedSpy.size(), opCode == QWebSocketProtocol::OpCodeText ? 1 : 0);
++ QCOMPARE(binaryFrameReceivedSpy.size(), opCode == QWebSocketProtocol::OpCodeBinary ? 1 : 0);
++ QCOMPARE(binaryMessageReceivedSpy.size(), opCode == QWebSocketProtocol::OpCodeBinary ? 1 : 0);
++
++ buffer.close();
++ }
++
++ void tst_DataProcessor::goodCloseFrame()
++ {
++ QByteArray data;
++ QBuffer buffer;
++ QWebSocketDataProcessor dataProcessor;
++ QFETCH(QString, payload);
++ QFETCH(QWebSocketProtocol::CloseCode, closeCode);
++ quint16 swapped = qToBigEndian<quint16>(closeCode);
++ const char *wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++
++ data.append(char(FIN | QWebSocketProtocol::OpCodeClose));
++ if (swapped != 0)
++ {
++ data.append(char(payload.size() + 2)).append(wireRepresentation, 2).append(payload.toUtf8());
++ }
++ else
++ {
++ data.append('\0'); //payload length 0;
++ //dataprocessor emits a CloseCodeNormal close code when none is present
++ closeCode = QWebSocketProtocol::CloseCodeNormal;
++ }
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++
++ QSignalSpy errorReceivedSpy(&dataProcessor,
++ SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy pingReceivedSpy(&dataProcessor, SIGNAL(pingReceived(QByteArray)));
++ QSignalSpy pongReceivedSpy(&dataProcessor, SIGNAL(pongReceived(QByteArray)));
++ QSignalSpy closeFrameReceivedSpy(&dataProcessor,
++ SIGNAL(closeReceived(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy textFrameReceivedSpy(&dataProcessor, SIGNAL(textFrameReceived(QString,bool)));
++ QSignalSpy textMessageReceivedSpy(&dataProcessor, SIGNAL(textMessageReceived(QString)));
++ QSignalSpy binaryFrameReceivedSpy(&dataProcessor, SIGNAL(binaryFrameReceived(QByteArray,bool)));
++ QSignalSpy binaryMessageReceivedSpy(&dataProcessor, SIGNAL(binaryMessageReceived(QByteArray)));
++
++ dataProcessor.process(&buffer);
++
++ QCOMPARE(errorReceivedSpy.size(), 0);
++ QCOMPARE(pingReceivedSpy.size(), 0);
++ QCOMPARE(pongReceivedSpy.size(), 0);
++ QCOMPARE(closeFrameReceivedSpy.size(), 1);
++ QCOMPARE(textFrameReceivedSpy.size(), 0);
++ QCOMPARE(textMessageReceivedSpy.size(), 0);
++ QCOMPARE(binaryFrameReceivedSpy.size(), 0);
++ QCOMPARE(binaryMessageReceivedSpy.size(), 0);
++ QList<QVariant> arguments = closeFrameReceivedSpy.takeFirst();
++ QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), closeCode);
++ QCOMPARE(arguments.at(1).toString().size(), payload.size());
++ buffer.close();
++ }
++
++ void tst_DataProcessor::nonCharacterCodes_data()
++ {
++ QTest::addColumn<quint8>("firstByte");
++ QTest::addColumn<quint8>("secondByte");
++ QTest::addColumn<QByteArray>("payload");
++ QTest::addColumn<bool>("isContinuationFrame");
++
++ nonCharacterSequence("efbfbe");
++ nonCharacterSequence("efbfbf");
++ nonCharacterSequence("f09fbfbe");
++ nonCharacterSequence("f09fbfbf");
++ nonCharacterSequence("f0afbfbe");
++ nonCharacterSequence("f0afbfbf");
++ nonCharacterSequence("f0bfbfbe");
++ nonCharacterSequence("f0bfbfbf");
++ nonCharacterSequence("f18fbfbe");
++ nonCharacterSequence("f18fbfbf");
++ nonCharacterSequence("f19fbfbe");
++ nonCharacterSequence("f19fbfbf");
++ nonCharacterSequence("f1afbfbe");
++ nonCharacterSequence("f1afbfbf");
++ nonCharacterSequence("f1bfbfbe");
++ nonCharacterSequence("f1bfbfbf");
++ nonCharacterSequence("f28fbfbe");
++ nonCharacterSequence("f28fbfbf");
++ nonCharacterSequence("f29fbfbe");
++ nonCharacterSequence("f29fbfbf");
++ nonCharacterSequence("f2afbfbe");
++ nonCharacterSequence("f2afbfbf");
++ nonCharacterSequence("f2bfbfbe");
++ nonCharacterSequence("f2bfbfbf");
++ nonCharacterSequence("f38fbfbe");
++ nonCharacterSequence("f38fbfbf");
++ nonCharacterSequence("f39fbfbe");
++ nonCharacterSequence("f39fbfbf");
++ nonCharacterSequence("f3afbfbe");
++ nonCharacterSequence("f3afbfbf");
++ nonCharacterSequence("f3bfbfbe");
++ nonCharacterSequence("f3bfbfbf");
++ nonCharacterSequence("f48fbfbe");
++ nonCharacterSequence("f48fbfbf");
++ }
++
++ void tst_DataProcessor::nonCharacterCodes()
++ {
++ QFETCH(quint8, firstByte);
++ QFETCH(quint8, secondByte);
++ QFETCH(QByteArray, payload);
++ QFETCH(bool, isContinuationFrame);
++
++ if (!isContinuationFrame)
++ {
++ QByteArray data;
++ QBuffer buffer;
++ QWebSocketDataProcessor dataProcessor;
++ QSignalSpy errorSpy(&dataProcessor,
++ SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy closeSpy(&dataProcessor,
++ SIGNAL(closeReceived(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy pingFrameSpy(&dataProcessor, SIGNAL(pingReceived(QByteArray)));
++ QSignalSpy pongFrameSpy(&dataProcessor, SIGNAL(pongReceived(QByteArray)));
++ QSignalSpy textFrameSpy(&dataProcessor, SIGNAL(textFrameReceived(QString,bool)));
++ QSignalSpy textMessageSpy(&dataProcessor, SIGNAL(textMessageReceived(QString)));
++ QSignalSpy binaryFrameSpy(&dataProcessor, SIGNAL(binaryFrameReceived(QByteArray,bool)));
++ QSignalSpy binaryMessageSpy(&dataProcessor, SIGNAL(binaryMessageReceived(QByteArray)));
++
++ data.append(firstByte).append(secondByte);
++ data.append(payload);
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++ dataProcessor.process(&buffer);
++
++ QCOMPARE(errorSpy.size(), 0);
++ QCOMPARE(closeSpy.size(), 0);
++ QCOMPARE(pingFrameSpy.size(), 0);
++ QCOMPARE(pongFrameSpy.size(), 0);
++ QCOMPARE(textFrameSpy.size(), 1);
++ QCOMPARE(textMessageSpy.size(), 1);
++ QCOMPARE(binaryFrameSpy.size(), 0);
++ QCOMPARE(binaryMessageSpy.size(), 0);
++
++ QVariantList arguments = textFrameSpy.takeFirst();
++ QCOMPARE(arguments.at(0).value<QString>().toUtf8(), payload);
++ QCOMPARE(arguments.at(1).value<bool>(), !isContinuationFrame);
++ arguments = textMessageSpy.takeFirst();
++ QCOMPARE(arguments.at(0).value<QString>().toUtf8(), payload);
++ buffer.close();
++ }
++ }
++
++ void tst_DataProcessor::frameTooSmall()
++ {
++ QByteArray data;
++ QBuffer buffer;
++ QWebSocketDataProcessor dataProcessor;
++ QByteArray firstFrame;
++
++ dataProcessor.setIdleTimeout(DefaultIdleTimeout);
++
++ firstFrame.append(quint8(QWebSocketProtocol::OpCodeText)).append(char(1))
++ .append(QByteArray(1, 'a'));
++
++ //with nothing in the buffer, the dataProcessor should time out
++ //and the error should be CloseCodeGoingAway meaning the socket will be closed
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++ QSignalSpy errorSpy(&dataProcessor,
++ SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy closeSpy(&dataProcessor,
++ SIGNAL(closeReceived(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy pingMessageSpy(&dataProcessor, SIGNAL(pingReceived(QByteArray)));
++ QSignalSpy pongMessageSpy(&dataProcessor, SIGNAL(pongReceived(QByteArray)));
++ QSignalSpy textMessageSpy(&dataProcessor, SIGNAL(textMessageReceived(QString)));
++ QSignalSpy binaryMessageSpy(&dataProcessor, SIGNAL(binaryMessageReceived(QByteArray)));
++ QSignalSpy textFrameSpy(&dataProcessor, SIGNAL(textFrameReceived(QString,bool)));
++ QSignalSpy binaryFrameSpy(&dataProcessor, SIGNAL(binaryFrameReceived(QByteArray,bool)));
++
++ dataProcessor.process(&buffer);
++
++ QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), 7000);
++ QCOMPARE(errorSpy.size(), 1);
++ QCOMPARE(closeSpy.size(), 0);
++ QCOMPARE(pingMessageSpy.size(), 0);
++ QCOMPARE(pongMessageSpy.size(), 0);
++ QCOMPARE(textMessageSpy.size(), 0);
++ QCOMPARE(binaryMessageSpy.size(), 0);
++ QCOMPARE(textFrameSpy.size(), 0);
++ QCOMPARE(binaryFrameSpy.size(), 0);
++
++ QList<QVariant> arguments = errorSpy.takeFirst();
++ QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
++ QWebSocketProtocol::CloseCodeGoingAway);
++ errorSpy.clear();
++ closeSpy.clear();
++ pingMessageSpy.clear();
++ pongMessageSpy.clear();
++ textMessageSpy.clear();
++ binaryMessageSpy.clear();
++ textFrameSpy.clear();
++ binaryFrameSpy.clear();
++ buffer.close();
++ data.clear();
++ dataProcessor.clear();
++
++ //only one byte; this is far too little;
++ //should get a time out as well and the error should be CloseCodeGoingAway
++ //meaning the socket will be closed
++ data.append(quint8('1')); //put 1 byte in the buffer; this is too little
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++
++ dataProcessor.process(&buffer);
++
++ QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), 7000);
++ QCOMPARE(errorSpy.size(), 1);
++ QCOMPARE(closeSpy.size(), 0);
++ QCOMPARE(pingMessageSpy.size(), 0);
++ QCOMPARE(pongMessageSpy.size(), 0);
++ QCOMPARE(textMessageSpy.size(), 0);
++ QCOMPARE(binaryMessageSpy.size(), 0);
++ QCOMPARE(textFrameSpy.size(), 0);
++ QCOMPARE(binaryFrameSpy.size(), 0);
++
++ arguments = errorSpy.takeFirst();
++ QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
++ QWebSocketProtocol::CloseCodeGoingAway);
++ buffer.close();
++ errorSpy.clear();
++ closeSpy.clear();
++ pingMessageSpy.clear();
++ pongMessageSpy.clear();
++ textMessageSpy.clear();
++ binaryMessageSpy.clear();
++ textFrameSpy.clear();
++ binaryFrameSpy.clear();
++ data.clear();
++ dataProcessor.clear();
++
++
++ {
++ //text frame with final bit not set
++ data.append(char(QWebSocketProtocol::OpCodeText)).append(char(0x0));
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++
++ dataProcessor.process(&buffer);
++
++ QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), 7000);
++ QCOMPARE(errorSpy.size(), 1);
++ QCOMPARE(closeSpy.size(), 0);
++ QCOMPARE(pingMessageSpy.size(), 0);
++ QCOMPARE(pongMessageSpy.size(), 0);
++ QCOMPARE(textMessageSpy.size(), 0);
++ QCOMPARE(binaryMessageSpy.size(), 0);
++ QCOMPARE(textFrameSpy.size(), 1);
++ QCOMPARE(binaryFrameSpy.size(), 0);
++
++ errorSpy.clear();
++ closeSpy.clear();
++ pingMessageSpy.clear();
++ pongMessageSpy.clear();
++ textMessageSpy.clear();
++ binaryMessageSpy.clear();
++ textFrameSpy.clear();
++ binaryFrameSpy.clear();
++ buffer.close();
++ data.clear();
++ dataProcessor.clear();
++
++ //with nothing in the buffer,
++ //the dataProcessor should time out and the error should be CloseCodeGoingAway
++ //meaning the socket will be closed
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++ dataProcessor.process(&buffer);
++
++ QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), 7000);
++ QCOMPARE(errorSpy.size(), 1);
++ QCOMPARE(closeSpy.size(), 0);
++ QCOMPARE(pingMessageSpy.size(), 0);
++ QCOMPARE(pongMessageSpy.size(), 0);
++ QCOMPARE(textMessageSpy.size(), 0);
++ QCOMPARE(binaryMessageSpy.size(), 0);
++ QCOMPARE(textFrameSpy.size(), 0);
++ QCOMPARE(binaryFrameSpy.size(), 0);
++
++ QList<QVariant> arguments = errorSpy.takeFirst();
++ QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
++ QWebSocketProtocol::CloseCodeGoingAway);
++ errorSpy.clear();
++ closeSpy.clear();
++ pingMessageSpy.clear();
++ pongMessageSpy.clear();
++ textMessageSpy.clear();
++ binaryMessageSpy.clear();
++ textFrameSpy.clear();
++ binaryFrameSpy.clear();
++ buffer.close();
++ data.clear();
++ dataProcessor.clear();
++
++ //text frame with final bit not set
++ data.append(char(QWebSocketProtocol::OpCodeText)).append(char(0x0));
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++ dataProcessor.process(&buffer);
++
++ QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), 7000);
++ QCOMPARE(errorSpy.size(), 1);
++ QCOMPARE(closeSpy.size(), 0);
++ QCOMPARE(pingMessageSpy.size(), 0);
++ QCOMPARE(pongMessageSpy.size(), 0);
++ QCOMPARE(textMessageSpy.size(), 0);
++ QCOMPARE(binaryMessageSpy.size(), 0);
++ QCOMPARE(textFrameSpy.size(), 1);
++ QCOMPARE(binaryFrameSpy.size(), 0);
++
++ buffer.close();
++ data.clear();
++ dataProcessor.clear();
++
++ errorSpy.clear();
++ closeSpy.clear();
++ pingMessageSpy.clear();
++ pongMessageSpy.clear();
++ textMessageSpy.clear();
++ binaryMessageSpy.clear();
++ textFrameSpy.clear();
++ binaryFrameSpy.clear();
++
++ //only 1 byte follows in continuation frame;
++ //should time out with close code CloseCodeGoingAway
++ data.append('a');
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++
++ dataProcessor.process(&buffer);
++ QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), 7000);
++ QCOMPARE(errorSpy.size(), 1);
++ QCOMPARE(closeSpy.size(), 0);
++ QCOMPARE(pingMessageSpy.size(), 0);
++ QCOMPARE(pongMessageSpy.size(), 0);
++ QCOMPARE(textMessageSpy.size(), 0);
++ QCOMPARE(binaryMessageSpy.size(), 0);
++ QCOMPARE(textFrameSpy.size(), 0);
++ QCOMPARE(binaryFrameSpy.size(), 0);
++ arguments = errorSpy.takeFirst();
++ QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(),
++ QWebSocketProtocol::CloseCodeGoingAway);
++ buffer.close();
++ }
++ }
++
++ void tst_DataProcessor::frameTooBig_data()
++ {
++ QTest::addColumn<quint8>("firstByte");
++ QTest::addColumn<quint8>("secondByte");
++ QTest::addColumn<QByteArray>("payload");
++ QTest::addColumn<bool>("isContinuationFrame");
++ QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedCloseCode");
++
++ quint64 swapped64 = 0;
++ const char *wireRepresentation = nullptr;
++
++ //only data frames are checked for being too big
++ //control frames have explicit checking on a maximum payload size of 125,
++ //which is tested elsewhere
++
++ swapped64 = qToBigEndian<quint64>(QWebSocketDataProcessor::maxFrameSize() + 1);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped64));
++ QTest::newRow("Text frame with payload size > INT_MAX")
++ << quint8(FIN | QWebSocketProtocol::OpCodeText)
++ << quint8(127)
++ << QByteArray(wireRepresentation, 8).append(QByteArray(32, 'a'))
++ << false
++ << QWebSocketProtocol::CloseCodeTooMuchData;
++
++ swapped64 = qToBigEndian<quint64>(QWebSocketDataProcessor::maxFrameSize() + 1);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped64));
++ QTest::newRow("Binary frame with payload size > INT_MAX")
++ << quint8(FIN | QWebSocketProtocol::OpCodeBinary)
++ << quint8(127)
++ << QByteArray(wireRepresentation, 8).append(QByteArray(32, 'a'))
++ << false
++ << QWebSocketProtocol::CloseCodeTooMuchData;
++
++ swapped64 = qToBigEndian<quint64>(QWebSocketDataProcessor::maxFrameSize() + 1);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped64));
++ QTest::newRow("Continuation frame with payload size > INT_MAX")
++ << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
++ << quint8(127)
++ << QByteArray(wireRepresentation, 8).append(QByteArray(32, 'a'))
++ << true
++ << QWebSocketProtocol::CloseCodeTooMuchData;
++ }
++
++ void tst_DataProcessor::frameTooBig()
++ {
++ doTest();
++ }
++
++ void tst_DataProcessor::invalidHeader_data()
++ {
++ //The first byte contain the FIN, RSV1, RSV2, RSV3 and the Opcode
++ //The second byte contains the MaskFlag and the length of the frame
++ QTest::addColumn<quint8>("firstByte");
++ QTest::addColumn<quint8>("secondByte");
++ //superfluous, but present to be able to call doTest(), which expects a payload field
++ QTest::addColumn<QByteArray>("payload");
++ QTest::addColumn<bool>("isContinuationFrame");
++ QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedCloseCode");
++
++ //invalid bit fields
++ invalidField("RSV1 set", RSV1);
++ invalidField("RSV2 set", RSV2);
++ invalidField("RSV3 set", RSV3);
++ invalidField("RSV1 and RSV2 set", RSV1 | RSV2);
++ invalidField("RSV1 and RSV3 set", RSV1 | RSV3);
++ invalidField("RSV2 and RSV3 set", RSV2 | RSV3);
++ invalidField("RSV1, RSV2 and RSV3 set", RSV1 | RSV2 | RSV3);
++
++ //invalid opcodes
++ invalidField("Invalid OpCode 3", QWebSocketProtocol::OpCodeReserved3);
++ invalidField("Invalid OpCode 4", QWebSocketProtocol::OpCodeReserved4);
++ invalidField("Invalid OpCode 5", QWebSocketProtocol::OpCodeReserved5);
++ invalidField("Invalid OpCode 6", QWebSocketProtocol::OpCodeReserved6);
++ invalidField("Invalid OpCode 7", QWebSocketProtocol::OpCodeReserved7);
++ invalidField("Invalid OpCode B", QWebSocketProtocol::OpCodeReservedB);
++ invalidField("Invalid OpCode C", QWebSocketProtocol::OpCodeReservedC);
++ invalidField("Invalid OpCode D", QWebSocketProtocol::OpCodeReservedD);
++ invalidField("Invalid OpCode E", QWebSocketProtocol::OpCodeReservedE);
++ invalidField("Invalid OpCode F", QWebSocketProtocol::OpCodeReservedF);
++ }
++
++ void tst_DataProcessor::invalidHeader()
++ {
++ doTest();
++ }
++
++ void tst_DataProcessor::invalidControlFrame_data()
++ {
++ QTest::addColumn<quint8>("firstByte");
++ QTest::addColumn<quint8>("secondByte");
++ QTest::addColumn<QByteArray>("payload");
++ QTest::addColumn<bool>("isContinuationFrame");
++ QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedCloseCode");
++
++
++ QTest::newRow("Close control frame with payload size 126")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(126)
++ << QByteArray()
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ QTest::newRow("Ping control frame with payload size 126")
++ << quint8(FIN | QWebSocketProtocol::OpCodePing)
++ << quint8(126)
++ << QByteArray()
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ QTest::newRow("Pong control frame with payload size 126")
++ << quint8(FIN | QWebSocketProtocol::OpCodePong)
++ << quint8(126)
++ << QByteArray()
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++
++ QTest::newRow("Non-final close control frame (fragmented)")
++ << quint8(QWebSocketProtocol::OpCodeClose)
++ << quint8(32)
++ << QByteArray()
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ QTest::newRow("Non-final ping control frame (fragmented)")
++ << quint8(QWebSocketProtocol::OpCodePing)
++ << quint8(32) << QByteArray()
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ QTest::newRow("Non-final pong control frame (fragmented)")
++ << quint8(QWebSocketProtocol::OpCodePong)
++ << quint8(32)
++ << QByteArray()
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ }
++
++ void tst_DataProcessor::invalidControlFrame()
++ {
++ doTest();
++ }
++
++ void tst_DataProcessor::invalidCloseFrame_data()
++ {
++ QTest::addColumn<quint8>("firstByte");
++ QTest::addColumn<quint8>("secondByte");
++ QTest::addColumn<QByteArray>("payload");
++ QTest::addColumn<bool>("isContinuationFrame");
++ QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedCloseCode");
++
++ QTest::newRow("Close control frame with payload size 1")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(1)
++ << QByteArray(1, 'a')
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ quint16 swapped = qToBigEndian<quint16>(QWebSocketProtocol::CloseCodeAbnormalDisconnection);
++ const char *wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++
++ //Not allowed per RFC 6455 (see para 7.4.1)
++ QTest::newRow("Close control frame close code ABNORMAL DISCONNECTION")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(2)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ swapped = qToBigEndian<quint16>(QWebSocketProtocol::CloseCodeMissingStatusCode);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++ //Not allowed per RFC 6455 (see para 7.4.1)
++ QTest::newRow("Close control frame close code MISSING STATUS CODE")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(2)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ swapped = qToBigEndian<quint16>(1004);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++ QTest::newRow("Close control frame close code 1004")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(2)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ swapped = qToBigEndian<quint16>(QWebSocketProtocol::CloseCodeTlsHandshakeFailed);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++ //Not allowed per RFC 6455 (see para 7.4.1)
++ QTest::newRow("Close control frame close code TLS HANDSHAKE FAILED")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(2)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ swapped = qToBigEndian<quint16>(0);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++ QTest::newRow("Close control frame close code 0")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(2)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ swapped = qToBigEndian<quint16>(999);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++ QTest::newRow("Close control frame close code 999")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(2)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ swapped = qToBigEndian<quint16>(1012);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++ QTest::newRow("Close control frame close code 1012")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(2)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ swapped = qToBigEndian<quint16>(1013);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++ QTest::newRow("Close control frame close code 1013")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(2)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ swapped = qToBigEndian<quint16>(1014);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++ QTest::newRow("Close control frame close code 1014")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(2)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ swapped = qToBigEndian<quint16>(1100);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++ QTest::newRow("Close control frame close code 1100")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(2)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ swapped = qToBigEndian<quint16>(2000);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++ QTest::newRow("Close control frame close code 2000")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(2)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ swapped = qToBigEndian<quint16>(2999);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++ QTest::newRow("Close control frame close code 2999")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(2)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ swapped = qToBigEndian<quint16>(5000);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++ QTest::newRow("Close control frame close code 5000")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(2)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ swapped = qToBigEndian<quint16>(65535u);
++ wireRepresentation = static_cast<const char *>(static_cast<const void *>(&swapped));
++ QTest::newRow("Close control frame close code 65535")
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(2)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ }
++
++ void tst_DataProcessor::invalidCloseFrame()
++ {
++ doCloseFrameTest();
++ }
++
++ void tst_DataProcessor::minimumSizeRequirement_data()
++ {
++ QTest::addColumn<quint8>("firstByte");
++ QTest::addColumn<quint8>("secondByte");
++ QTest::addColumn<QByteArray>("payload");
++ QTest::addColumn<bool>("isContinuationFrame");
++ QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedCloseCode");
++
++ minimumSize16Bit(0);
++ minimumSize16Bit(64);
++ minimumSize16Bit(125);
++
++ minimumSize64Bit(0);
++ minimumSize64Bit(64);
++ minimumSize64Bit(125);
++ minimumSize64Bit(126);
++ minimumSize64Bit(256);
++ minimumSize64Bit(512);
++ minimumSize64Bit(1024);
++ minimumSize64Bit(2048);
++ minimumSize64Bit(4096);
++ minimumSize64Bit(8192);
++ minimumSize64Bit(16384);
++ minimumSize64Bit(32768);
++ minimumSize64Bit(0xFFFFu);
++ }
++
++ void tst_DataProcessor::minimumSizeRequirement()
++ {
++ doTest();
++ }
++
++ void tst_DataProcessor::invalidPayload_data(bool isControlFrame)
++ {
++ QTest::addColumn<quint8>("firstByte");
++ QTest::addColumn<quint8>("secondByte");
++ QTest::addColumn<QByteArray>("payload");
++ QTest::addColumn<bool>("isContinuationFrame");
++ QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedCloseCode");
++
++ //6.3: invalid UTF-8 sequence
++ invalidUTF8("case 6.3.1", "cebae1bdb9cf83cebcceb5eda080656469746564", isControlFrame);
++
++ //6.4.: fail fast tests; invalid UTF-8 in middle of string
++ invalidUTF8("case 6.4.1", "cebae1bdb9cf83cebcceb5f4908080656469746564", isControlFrame);
++ invalidUTF8("case 6.4.4", "cebae1bdb9cf83cebcceb5eda080656469746564", isControlFrame);
++
++ //6.6: All prefixes of a valid UTF-8 string that contains multi-byte code points
++ invalidUTF8("case 6.6.1", "ce", isControlFrame);
++ invalidUTF8("case 6.6.3", "cebae1", isControlFrame);
++ invalidUTF8("case 6.6.4", "cebae1bd", isControlFrame);
++ invalidUTF8("case 6.6.6", "cebae1bdb9cf", isControlFrame);
++ invalidUTF8("case 6.6.8", "cebae1bdb9cf83ce", isControlFrame);
++ invalidUTF8("case 6.6.10", "cebae1bdb9cf83cebcce", isControlFrame);
++
++ //6.8: First possible sequence length 5/6 (invalid codepoints)
++ invalidUTF8("case 6.8.1", "f888808080", isControlFrame);
++ invalidUTF8("case 6.8.2", "fc8480808080", isControlFrame);
++
++ //6.10: Last possible sequence length 4/5/6 (invalid codepoints)
++ invalidUTF8("case 6.10.1", "f7bfbfbf", isControlFrame);
++ invalidUTF8("case 6.10.2", "fbbfbfbfbf", isControlFrame);
++ invalidUTF8("case 6.10.3", "fdbfbfbfbfbf", isControlFrame);
++
++ //5.11: boundary conditions
++ invalidUTF8("case 6.11.5", "f4908080", isControlFrame);
++
++ //6.12: unexpected continuation bytes
++ invalidUTF8("case 6.12.1", "80", isControlFrame);
++ invalidUTF8("case 6.12.2", "bf", isControlFrame);
++ invalidUTF8("case 6.12.3", "80bf", isControlFrame);
++ invalidUTF8("case 6.12.4", "80bf80", isControlFrame);
++ invalidUTF8("case 6.12.5", "80bf80bf", isControlFrame);
++ invalidUTF8("case 6.12.6", "80bf80bf80", isControlFrame);
++ invalidUTF8("case 6.12.7", "80bf80bf80bf", isControlFrame);
++ invalidUTF8("case 6.12.8",
++ "808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a"
++ "7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbe",
++ isControlFrame);
++
++ //6.13: lonely start characters
++ invalidUTF8("case 6.13.1",
++ "c020c120c220c320c420c520c620c720c820c920ca20cb20cc20cd20ce20cf20d020d120d220"
++ "d320d420d520d620d720d820d920da20db20dc20dd20de20",
++ isControlFrame);
++ invalidUTF8("case 6.13.2", "e020e120e220e320e420e520e620e720e820e920ea20eb20ec20ed20ee20",
++ isControlFrame);
++ invalidUTF8("case 6.13.3", "f020f120f220f320f420f520f620", isControlFrame);
++ invalidUTF8("case 6.13.4", "f820f920fa20", isControlFrame);
++ invalidUTF8("case 6.13.5", "fc20", isControlFrame);
++
++ //6.14: sequences with last continuation byte missing
++ invalidUTF8("case 6.14.1", "c0", isControlFrame);
++ invalidUTF8("case 6.14.2", "e080", isControlFrame);
++ invalidUTF8("case 6.14.3", "f08080", isControlFrame);
++ invalidUTF8("case 6.14.4", "f8808080", isControlFrame);
++ invalidUTF8("case 6.14.5", "fc80808080", isControlFrame);
++ invalidUTF8("case 6.14.6", "df", isControlFrame);
++ invalidUTF8("case 6.14.7", "efbf", isControlFrame);
++ invalidUTF8("case 6.14.8", "f7bfbf", isControlFrame);
++ invalidUTF8("case 6.14.9", "fbbfbfbf", isControlFrame);
++ invalidUTF8("case 6.14.10", "fdbfbfbfbf", isControlFrame);
++
++ //6.15: concatenation of incomplete sequences
++ invalidUTF8("case 6.15.1",
++ "c0e080f08080f8808080fc80808080dfefbff7bfbffbbfbfbffdbfbfbfbf", isControlFrame);
++
++ //6.16: impossible bytes
++ invalidUTF8("case 6.16.1", "fe", isControlFrame);
++ invalidUTF8("case 6.16.2", "ff", isControlFrame);
++ invalidUTF8("case 6.16.3", "fefeffff", isControlFrame);
++
++ //6.17: overlong ASCII characters
++ invalidUTF8("case 6.17.1", "c0af", isControlFrame);
++ invalidUTF8("case 6.17.2", "e080af", isControlFrame);
++ invalidUTF8("case 6.17.3", "f08080af", isControlFrame);
++ invalidUTF8("case 6.17.4", "f8808080af", isControlFrame);
++ invalidUTF8("case 6.17.5", "fc80808080af", isControlFrame);
++
++ //6.18: maximum overlong sequences
++ invalidUTF8("case 6.18.1", "c1bf", isControlFrame);
++ invalidUTF8("case 6.18.2", "e09fbf", isControlFrame);
++ invalidUTF8("case 6.18.3", "f08fbfbf", isControlFrame);
++ invalidUTF8("case 6.18.4", "f887bfbfbf", isControlFrame);
++ invalidUTF8("case 6.18.5", "fc83bfbfbfbf", isControlFrame);
++
++ //6.19: overlong presentation of the NUL character
++ invalidUTF8("case 6.19.1", "c080", isControlFrame);
++ invalidUTF8("case 6.19.2", "e08080", isControlFrame);
++ invalidUTF8("case 6.19.3", "f0808080", isControlFrame);
++ invalidUTF8("case 6.19.4", "f880808080", isControlFrame);
++ invalidUTF8("case 6.19.5", "fc8080808080", isControlFrame);
++
++ //6.20: Single UTF-16 surrogates
++ invalidUTF8("case 6.20.1", "eda080", isControlFrame);
++ invalidUTF8("case 6.20.2", "edadbf", isControlFrame);
++ invalidUTF8("case 6.20.3", "edae80", isControlFrame);
++ invalidUTF8("case 6.20.4", "edafbf", isControlFrame);
++ invalidUTF8("case 6.20.5", "edb080", isControlFrame);
++ invalidUTF8("case 6.20.6", "edbe80", isControlFrame);
++ invalidUTF8("case 6.20.7", "edbfbf", isControlFrame);
++
++ //6.21: Paired UTF-16 surrogates
++ invalidUTF8("case 6.21.1", "eda080edb080", isControlFrame);
++ invalidUTF8("case 6.21.2", "eda080edbfbf", isControlFrame);
++ invalidUTF8("case 6.21.3", "edadbfedb080", isControlFrame);
++ invalidUTF8("case 6.21.4", "edadbfedbfbf", isControlFrame);
++ invalidUTF8("case 6.21.5", "edae80edb080", isControlFrame);
++ invalidUTF8("case 6.21.6", "edae80edbfbf", isControlFrame);
++ invalidUTF8("case 6.21.7", "edafbfedb080", isControlFrame);
++ invalidUTF8("case 6.21.8", "edafbfedbfbf", isControlFrame);
++ }
++
++ void tst_DataProcessor::invalidPayload()
++ {
++ doTest();
++ }
++
++ void tst_DataProcessor::invalidPayloadInCloseFrame_data()
++ {
++ invalidPayload_data(true);
++ }
++
++ void tst_DataProcessor::invalidPayloadInCloseFrame()
++ {
++ QFETCH(quint8, firstByte);
++ QFETCH(quint8, secondByte);
++ QFETCH(QByteArray, payload);
++ QFETCH(bool, isContinuationFrame);
++ QFETCH(QWebSocketProtocol::CloseCode, expectedCloseCode);
++
++ Q_UNUSED(isContinuationFrame);
++
++ QByteArray data;
++ QBuffer buffer;
++ QWebSocketDataProcessor dataProcessor;
++ QSignalSpy closeSpy(&dataProcessor,
++ SIGNAL(closeReceived(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy errorSpy(&dataProcessor,
++ SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy pingMessageSpy(&dataProcessor, SIGNAL(pingReceived(QByteArray)));
++ QSignalSpy pongMessageSpy(&dataProcessor, SIGNAL(pongReceived(QByteArray)));
++ QSignalSpy textMessageSpy(&dataProcessor, SIGNAL(textMessageReceived(QString)));
++ QSignalSpy binaryMessageSpy(&dataProcessor, SIGNAL(binaryMessageReceived(QByteArray)));
++ QSignalSpy textFrameSpy(&dataProcessor, SIGNAL(textFrameReceived(QString,bool)));
++ QSignalSpy binaryFrameSpy(&dataProcessor, SIGNAL(binaryFrameReceived(QByteArray,bool)));
++
++ dataProcessor.setIdleTimeout(DefaultIdleTimeout);
++
++ data.append(firstByte).append(secondByte);
++ data.append(payload);
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++ dataProcessor.process(&buffer);
++ QCOMPARE(closeSpy.size(), 1);
++ QCOMPARE(errorSpy.size(), 0);
++ QCOMPARE(pingMessageSpy.size(), 0);
++ QCOMPARE(pongMessageSpy.size(), 0);
++ QCOMPARE(textMessageSpy.size(), 0);
++ QCOMPARE(binaryMessageSpy.size(), 0);
++ QCOMPARE(textFrameSpy.size(), 0);
++ QCOMPARE(binaryFrameSpy.size(), 0);
++ QVariantList arguments = closeSpy.takeFirst();
++ QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), expectedCloseCode);
++ buffer.close();
++ }
++
++ void tst_DataProcessor::incompletePayload_data()
++ {
++ QTest::addColumn<quint8>("firstByte");
++ QTest::addColumn<quint8>("secondByte");
++ QTest::addColumn<QByteArray>("payload");
++ QTest::addColumn<bool>("isContinuationFrame");
++ QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedCloseCode");
++
++ incompleteFrame(QWebSocketProtocol::OpCodeText, 125, 0);
++ incompleteFrame(QWebSocketProtocol::OpCodeText, 64, 32);
++ incompleteFrame(QWebSocketProtocol::OpCodeText, 256, 32);
++ incompleteFrame(QWebSocketProtocol::OpCodeText, 128000, 32);
++ incompleteFrame(QWebSocketProtocol::OpCodeBinary, 125, 0);
++ incompleteFrame(QWebSocketProtocol::OpCodeBinary, 64, 32);
++ incompleteFrame(QWebSocketProtocol::OpCodeBinary, 256, 32);
++ incompleteFrame(QWebSocketProtocol::OpCodeBinary, 128000, 32);
++ incompleteFrame(QWebSocketProtocol::OpCodeContinue, 125, 0);
++ incompleteFrame(QWebSocketProtocol::OpCodeContinue, 64, 32);
++ incompleteFrame(QWebSocketProtocol::OpCodeContinue, 256, 32);
++ incompleteFrame(QWebSocketProtocol::OpCodeContinue, 128000, 32);
++
++ incompleteFrame(QWebSocketProtocol::OpCodeClose, 64, 32);
++ incompleteFrame(QWebSocketProtocol::OpCodePing, 64, 32);
++ incompleteFrame(QWebSocketProtocol::OpCodePong, 64, 32);
++ }
++
++ void tst_DataProcessor::incompletePayload()
++ {
++ doTest(7000);
++ }
++
++ void tst_DataProcessor::incompleteSizeField_data()
++ {
++ QTest::addColumn<quint8>("firstByte");
++ QTest::addColumn<quint8>("secondByte");
++ QTest::addColumn<QByteArray>("payload");
++ QTest::addColumn<bool>("isContinuationFrame");
++ QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedCloseCode");
++
++ //for a frame length value of 126
++ //there should be 2 bytes following to form a 16-bit frame length
++ insertIncompleteSizeFieldTest(126, 0);
++ insertIncompleteSizeFieldTest(126, 1);
++
++ //for a frame length value of 127
++ //there should be 8 bytes following to form a 64-bit frame length
++ insertIncompleteSizeFieldTest(127, 0);
++ insertIncompleteSizeFieldTest(127, 1);
++ insertIncompleteSizeFieldTest(127, 2);
++ insertIncompleteSizeFieldTest(127, 3);
++ insertIncompleteSizeFieldTest(127, 4);
++ insertIncompleteSizeFieldTest(127, 5);
++ insertIncompleteSizeFieldTest(127, 6);
++ insertIncompleteSizeFieldTest(127, 7);
++ }
++
++ void tst_DataProcessor::incompleteSizeField()
++ {
++ doTest(7000);
++ }
++
++ //////////////////////////////////////////////////////////////////////////////////////////
++ /// HELPER FUNCTIONS
++ //////////////////////////////////////////////////////////////////////////////////////////
++ void tst_DataProcessor::doTest(int timeout)
++ {
++ QFETCH(quint8, firstByte);
++ QFETCH(quint8, secondByte);
++ QFETCH(QByteArray, payload);
++ QFETCH(bool, isContinuationFrame);
++ QFETCH(QWebSocketProtocol::CloseCode, expectedCloseCode);
++
++ QByteArray data;
++ QBuffer buffer;
++ QWebSocketDataProcessor dataProcessor;
++ QSignalSpy errorSpy(&dataProcessor,
++ SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy textMessageSpy(&dataProcessor, SIGNAL(textMessageReceived(QString)));
++ QSignalSpy binaryMessageSpy(&dataProcessor, SIGNAL(binaryMessageReceived(QByteArray)));
++ QSignalSpy textFrameSpy(&dataProcessor, SIGNAL(textFrameReceived(QString,bool)));
++ QSignalSpy binaryFrameSpy(&dataProcessor, SIGNAL(binaryFrameReceived(QByteArray,bool)));
++
++ dataProcessor.setIdleTimeout(DefaultIdleTimeout);
++
++ if (isContinuationFrame)
++ {
++ data.append(quint8(QWebSocketProtocol::OpCodeText))
++ .append(char(1))
++ .append(QByteArray(1, 'a'));
++ }
++ data.append(firstByte).append(secondByte);
++ data.append(payload);
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++ dataProcessor.process(&buffer);
++ QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), timeout);
++ QCOMPARE(errorSpy.size(), 1);
++ QCOMPARE(textMessageSpy.size(), 0);
++ QCOMPARE(binaryMessageSpy.size(), 0);
++ QCOMPARE(textFrameSpy.size(), isContinuationFrame ? 1 : 0);
++ QCOMPARE(binaryFrameSpy.size(), 0);
++ QVariantList arguments = errorSpy.takeFirst();
++ QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), expectedCloseCode);
++ buffer.close();
++ errorSpy.clear();
++ data.clear();
++ }
++
++ void tst_DataProcessor::doCloseFrameTest()
++ {
++ QFETCH(quint8, firstByte);
++ QFETCH(quint8, secondByte);
++ QFETCH(QByteArray, payload);
++ QFETCH(bool, isContinuationFrame);
++ QFETCH(QWebSocketProtocol::CloseCode, expectedCloseCode);
++
++ Q_UNUSED(isContinuationFrame);
++
++ QByteArray data;
++ QBuffer buffer;
++ QWebSocketDataProcessor dataProcessor;
++ QSignalSpy closeSpy(&dataProcessor,
++ SIGNAL(closeReceived(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy errorSpy(&dataProcessor,
++ SIGNAL(errorEncountered(QWebSocketProtocol::CloseCode,QString)));
++ QSignalSpy textMessageSpy(&dataProcessor, SIGNAL(textMessageReceived(QString)));
++ QSignalSpy binaryMessageSpy(&dataProcessor, SIGNAL(binaryMessageReceived(QByteArray)));
++ QSignalSpy textFrameSpy(&dataProcessor, SIGNAL(textFrameReceived(QString,bool)));
++ QSignalSpy binaryFrameSpy(&dataProcessor, SIGNAL(binaryFrameReceived(QByteArray,bool)));
++
++ dataProcessor.setIdleTimeout(DefaultIdleTimeout);
++
++ data.append(firstByte).append(secondByte);
++ data.append(payload);
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++ dataProcessor.process(&buffer);
++ QCOMPARE(closeSpy.size(), 1);
++ QCOMPARE(errorSpy.size(), 0);
++ QCOMPARE(textMessageSpy.size(), 0);
++ QCOMPARE(binaryMessageSpy.size(), 0);
++ QCOMPARE(textFrameSpy.size(), 0);
++ QCOMPARE(binaryFrameSpy.size(), 0);
++ QVariantList arguments = closeSpy.takeFirst();
++ QCOMPARE(arguments.at(0).value<QWebSocketProtocol::CloseCode>(), expectedCloseCode);
++ buffer.close();
++ }
++
++ QString tst_DataProcessor::opCodeToString(quint8 opCode)
++ {
++ QString frameType;
++ switch (opCode)
++ {
++ case QWebSocketProtocol::OpCodeBinary:
++ {
++ frameType = QStringLiteral("Binary");
++ break;
++ }
++ case QWebSocketProtocol::OpCodeText:
++ {
++ frameType = QStringLiteral("Text");
++ break;
++ }
++ case QWebSocketProtocol::OpCodePing:
++ {
++ frameType = QStringLiteral("Ping");
++ break;
++ }
++ case QWebSocketProtocol::OpCodePong:
++ {
++ frameType = QStringLiteral("Pong");
++ break;
++ }
++ case QWebSocketProtocol::OpCodeClose:
++ {
++ frameType = QStringLiteral("Close");
++ break;
++ }
++ case QWebSocketProtocol::OpCodeContinue:
++ {
++ frameType = QStringLiteral("Continuation");
++ break;
++ }
++ case QWebSocketProtocol::OpCodeReserved3:
++ {
++ frameType = QStringLiteral("Reserved3");
++ break;
++ }
++ case QWebSocketProtocol::OpCodeReserved4:
++ {
++ frameType = QStringLiteral("Reserved5");
++ break;
++ }
++ case QWebSocketProtocol::OpCodeReserved5:
++ {
++ frameType = QStringLiteral("Reserved5");
++ break;
++ }
++ case QWebSocketProtocol::OpCodeReserved6:
++ {
++ frameType = QStringLiteral("Reserved6");
++ break;
++ }
++ case QWebSocketProtocol::OpCodeReserved7:
++ {
++ frameType = QStringLiteral("Reserved7");
++ break;
++ }
++ case QWebSocketProtocol::OpCodeReservedB:
++ {
++ frameType = QStringLiteral("ReservedB");
++ break;
++ }
++ case QWebSocketProtocol::OpCodeReservedC:
++ {
++ frameType = QStringLiteral("ReservedC");
++ break;
++ }
++ case QWebSocketProtocol::OpCodeReservedD:
++ {
++ frameType = QStringLiteral("ReservedD");
++ break;
++ }
++ case QWebSocketProtocol::OpCodeReservedE:
++ {
++ frameType = QStringLiteral("ReservedE");
++ break;
++ }
++ case QWebSocketProtocol::OpCodeReservedF:
++ {
++ frameType = QStringLiteral("ReservedF");
++ break;
++ }
++ default:
++ {
++ //should never come here
++ Q_ASSERT(false);
++ }
++ }
++ return frameType;
++ }
++
++ void tst_DataProcessor::minimumSize16Bit(quint16 sizeInBytes)
++ {
++ quint16 swapped16 = qToBigEndian<quint16>(sizeInBytes);
++ const char *wireRepresentation
++ = static_cast<const char *>(static_cast<const void *>(&swapped16));
++ QTest::newRow(QStringLiteral("Text frame with payload size %1, represented in 2 bytes")
++ .arg(sizeInBytes).toLatin1().constData())
++ << quint8(FIN | QWebSocketProtocol::OpCodeText)
++ << quint8(126)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ QTest::newRow(QStringLiteral("Binary frame with payload size %1, represented in 2 bytes")
++ .arg(sizeInBytes).toLatin1().constBegin())
++ << quint8(FIN | QWebSocketProtocol::OpCodeBinary)
++ << quint8(126)
++ << QByteArray(wireRepresentation, 2)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ QTest::newRow(QStringLiteral("Continuation frame with payload size %1, represented in 2 bytes")
++ .arg(sizeInBytes).toLatin1().constData())
++ << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
++ << quint8(126)
++ << QByteArray(wireRepresentation, 2)
++ << true
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ }
++
++ void tst_DataProcessor::minimumSize64Bit(quint64 sizeInBytes)
++ {
++ quint64 swapped64 = qToBigEndian<quint64>(sizeInBytes);
++ const char *wireRepresentation
++ = static_cast<const char *>(static_cast<const void *>(&swapped64));
++
++ QTest::newRow(QStringLiteral("Text frame with payload size %1, represented in 8 bytes")
++ .arg(sizeInBytes).toLatin1().constData())
++ << quint8(FIN | QWebSocketProtocol::OpCodeText)
++ << quint8(127)
++ << QByteArray(wireRepresentation, 8)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++
++ QTest::newRow(QStringLiteral("Binary frame with payload size %1, represented in 8 bytes")
++ .arg(sizeInBytes).toLatin1().constData())
++ << quint8(FIN | QWebSocketProtocol::OpCodeBinary)
++ << quint8(127)
++ << QByteArray(wireRepresentation, 8)
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++
++ QTest::newRow(QStringLiteral("Continuation frame with payload size %1, represented in 8 bytes")
++ .arg(sizeInBytes).toLatin1().constData())
++ << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
++ << quint8(127)
++ << QByteArray(wireRepresentation, 8)
++ << true
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ }
++
++ void tst_DataProcessor::invalidUTF8(const char *dataTag, const char *utf8Sequence,
++ bool isCloseFrame)
++ {
++ QByteArray payload = QByteArray::fromHex(utf8Sequence);
++
++ if (isCloseFrame)
++ {
++ quint16 closeCode = qToBigEndian<quint16>(QWebSocketProtocol::CloseCodeNormal);
++ const char *wireRepresentation
++ = static_cast<const char *>(static_cast<const void *>(&closeCode));
++ QTest::newRow(QStringLiteral("Close frame with invalid UTF8-sequence: %1")
++ .arg(dataTag).toLatin1().constData())
++ << quint8(FIN | QWebSocketProtocol::OpCodeClose)
++ << quint8(payload.size() + 2)
++ << QByteArray(wireRepresentation, 2).append(payload)
++ << false
++ << QWebSocketProtocol::CloseCodeWrongDatatype;
++ }
++ else
++ {
++ QTest::newRow(QStringLiteral("Text frame with invalid UTF8-sequence: %1")
++ .arg(dataTag).toLatin1().constData())
++ << quint8(FIN | QWebSocketProtocol::OpCodeText)
++ << quint8(payload.size())
++ << payload
++ << false
++ << QWebSocketProtocol::CloseCodeWrongDatatype;
++
++ QTest::newRow(QStringLiteral("Continuation text frame with invalid UTF8-sequence: %1")
++ .arg(dataTag).toLatin1().constData())
++ << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
++ << quint8(payload.size())
++ << payload
++ << true
++ << QWebSocketProtocol::CloseCodeWrongDatatype;
++ }
++ }
++
++ void tst_DataProcessor::invalidField(const char *dataTag, quint8 invalidFieldValue)
++ {
++ QTest::newRow(dataTag) << quint8(FIN | invalidFieldValue)
++ << quint8(0x00)
++ << QByteArray()
++ << false
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ QTest::newRow(QString::fromLatin1(dataTag).append(QStringLiteral(" with continuation frame"))
++ .toLatin1().constData())
++ << quint8(FIN | invalidFieldValue)
++ << quint8(0x00)
++ << QByteArray()
++ << true
++ << QWebSocketProtocol::CloseCodeProtocolError;
++ }
++
++ void tst_DataProcessor::incompleteFrame(quint8 controlCode, quint64 indicatedSize,
++ quint64 actualPayloadSize)
++ {
++ QVERIFY(!QWebSocketProtocol::isOpCodeReserved(QWebSocketProtocol::OpCode(controlCode)));
++ QVERIFY(indicatedSize > actualPayloadSize);
++
++ QString frameType = opCodeToString(controlCode);
++ QByteArray firstFrame;
++
++ if (indicatedSize < 126)
++ {
++ //doing extensive QStringLiteral concatenations here, because
++ //MSVC 2010 complains when using concatenation literal strings about
++ //concatenation of wide and narrow strings (error C2308)
++ QTest::newRow(frameType
++ .append(QStringLiteral(" frame with payload size %1, but only %2 bytes") +
++ QStringLiteral(" of data")
++ .arg(indicatedSize).arg(actualPayloadSize)).toLatin1().constData())
++ << quint8(FIN | controlCode)
++ << quint8(indicatedSize)
++ << firstFrame.append(QByteArray(actualPayloadSize, 'a'))
++ << (controlCode == QWebSocketProtocol::OpCodeContinue)
++ << QWebSocketProtocol::CloseCodeGoingAway;
++ }
++ else if (indicatedSize <= 0xFFFFu)
++ {
++ quint16 swapped16 = qToBigEndian<quint16>(static_cast<quint16>(indicatedSize));
++ const char *wireRepresentation
++ = static_cast<const char *>(static_cast<const void *>(&swapped16));
++ QTest::newRow(
++ frameType.append(QStringLiteral(" frame with payload size %1, but only ") +
++ QStringLiteral("%2 bytes of data")
++ .arg(indicatedSize)
++ .arg(actualPayloadSize)).toLatin1().constData())
++ << quint8(FIN | controlCode)
++ << quint8(126)
++ << firstFrame.append(QByteArray(wireRepresentation, 2)
++ .append(QByteArray(actualPayloadSize, 'a')))
++ << (controlCode == QWebSocketProtocol::OpCodeContinue)
++ << QWebSocketProtocol::CloseCodeGoingAway;
++ }
++ else
++ {
++ quint64 swapped64 = qToBigEndian<quint64>(indicatedSize);
++ const char *wireRepresentation
++ = static_cast<const char *>(static_cast<const void *>(&swapped64));
++ QTest::newRow(frameType
++ .append(QStringLiteral(" frame with payload size %1, but only %2 bytes ") +
++ QStringLiteral("of data")
++ .arg(indicatedSize).arg(actualPayloadSize)).toLatin1().constData())
++ << quint8(FIN | controlCode)
++ << quint8(127)
++ << firstFrame.append(QByteArray(wireRepresentation, 8)
++ .append(QByteArray(actualPayloadSize, 'a')))
++ << (controlCode == QWebSocketProtocol::OpCodeContinue)
++ << QWebSocketProtocol::CloseCodeGoingAway;
++ }
++ }
++
++ void tst_DataProcessor::nonCharacterSequence(const char *sequence)
++ {
++ QByteArray utf8Sequence = QByteArray::fromHex(sequence);
++
++ //doing extensive QStringLiteral concatenations here, because
++ //MSVC 2010 complains when using concatenation literal strings about
++ //concatenation of wide and narrow strings (error C2308)
++ QTest::newRow((QStringLiteral("Text frame with payload containing the non-control character ") +
++ QStringLiteral("sequence 0x%1"))
++ .arg(QString::fromLocal8Bit(sequence)).toLatin1().constData())
++ << quint8(FIN | QWebSocketProtocol::OpCodeText)
++ << quint8(utf8Sequence.size())
++ << utf8Sequence
++ << false;
++
++ QTest::newRow((QStringLiteral("Continuation frame with payload containing the non-control ") +
++ QStringLiteral("character sequence 0x%1"))
++ .arg(QString::fromLocal8Bit(sequence)).toLatin1().constData())
++ << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
++ << quint8(utf8Sequence.size())
++ << utf8Sequence
++ << true;
++ }
++
++ void tst_DataProcessor::insertIncompleteSizeFieldTest(quint8 payloadCode, quint8 numBytesFollowing)
++ {
++ //doing extensive QStringLiteral concatenations here, because
++ //MSVC 2010 complains when using concatenation literal strings about
++ //concatenation of wide and narrow strings (error C2308)
++ QTest::newRow(QStringLiteral("Text frame with payload size %1, with %2 bytes following.")
++ .arg(payloadCode).arg(numBytesFollowing).toLatin1().constData())
++ << quint8(FIN | QWebSocketProtocol::OpCodeText)
++ << quint8(payloadCode)
++ << QByteArray(numBytesFollowing, quint8(1))
++ << false
++ << QWebSocketProtocol::CloseCodeGoingAway;
++ QTest::newRow(QStringLiteral("Binary frame with payload size %1, with %2 bytes following.")
++ .arg(payloadCode).arg(numBytesFollowing).toLatin1().constData())
++ << quint8(FIN | QWebSocketProtocol::OpCodeBinary)
++ << quint8(payloadCode)
++ << QByteArray(numBytesFollowing, quint8(1))
++ << false
++ << QWebSocketProtocol::CloseCodeGoingAway;
++ QTest::newRow((QStringLiteral("Continuation frame with payload size %1, with %2 bytes ") +
++ QStringLiteral("following."))
++ .arg(payloadCode).arg(numBytesFollowing).toLatin1().constData())
++ << quint8(FIN | QWebSocketProtocol::OpCodeContinue)
++ << quint8(payloadCode)
++ << QByteArray(numBytesFollowing, quint8(1))
++ << true
++ << QWebSocketProtocol::CloseCodeGoingAway;
++ }
++
++ void tst_DataProcessor::clearDataBuffers()
++ {
++ const QByteArray binaryData("Hello!");
++ QByteArray data;
++ data.append(char(FIN | QWebSocketProtocol::OpCodeBinary));
++ data.append(char(binaryData.size()));
++ data.append(binaryData);
++
++ QWebSocketDataProcessor dataProcessor;
++ dataProcessor.setIdleTimeout(DefaultIdleTimeout);
++ connect(&dataProcessor, &QWebSocketDataProcessor::binaryMessageReceived,
++ this, [&binaryData](const QByteArray &message)
++ {
++ QCOMPARE(message, binaryData);
++ QEventLoop loop;
++ QTimer::singleShot(2000, &loop, SLOT(quit()));
++ loop.exec();
++ });
++
++ QBuffer buffer;
++ buffer.setData(data);
++ auto processData = [&dataProcessor, &buffer]()
++ {
++ buffer.open(QIODevice::ReadOnly);
++ dataProcessor.process(&buffer);
++ buffer.close();
++ };
++
++ QTimer timer;
++ timer.setSingleShot(true);
++ connect(&timer, &QTimer::timeout, this, processData);
++
++ timer.start(1000);
++ processData();
++ QTest::qWait(2000);
++ }
++
++ void tst_DataProcessor::stopProcessingOnError_data()
++ {
++ QTest::addColumn<QByteArray>("data");
++ QTest::addColumn<QWebSocketProtocol::CloseCode>("expectedCloseCode");
++ // frames legitimately delivered before the violation is detected
++ QTest::addColumn<int>("expectedTextFrames");
++ // zero leaves the default limit in place
++ QTest::addColumn<quint64>("maxMessageSize");
++
++ // the well formed frame trailing most rows; it must never be delivered
++ QByteArray textFrame;
++ textFrame.append(char(FIN | QWebSocketProtocol::OpCodeText));
++ textFrame.append(char(5));
++ textFrame.append("hello");
++
++ // Ensure a continuation frame that has no message to continue is rejected,
++ // and that the text frame behind it is not delivered.
++ QByteArray strayContinuation;
++ strayContinuation.append(char(FIN | QWebSocketProtocol::OpCodeContinue));
++ strayContinuation.append(char(0));
++ QTest::newRow("stray continuation frame")
++ << strayContinuation + textFrame << QWebSocketProtocol::CloseCodeProtocolError
++ << 0 << quint64(0);
++
++ // Ensure a frame rejected on its header does not leak the payload it
++ // announced.
++ QByteArray rsv1Frame;
++ rsv1Frame.append(char(FIN | RSV1 | QWebSocketProtocol::OpCodeText));
++ rsv1Frame.append(char(textFrame.size()));
++ QTest::newRow("rsv1 set, announced payload is a frame")
++ << rsv1Frame + textFrame << QWebSocketProtocol::CloseCodeProtocolError
++ << 0 << quint64(0);
++
++ // Ensure a payload that fails UTF-8 validation stops processing.
++ QByteArray invalidUtf8Frame;
++ invalidUtf8Frame.append(char(FIN | QWebSocketProtocol::OpCodeText));
++ invalidUtf8Frame.append(char(1));
++ invalidUtf8Frame.append(char(0xFF));
++ QTest::newRow("invalid utf-8")
++ << invalidUtf8Frame + textFrame << QWebSocketProtocol::CloseCodeWrongDatatype
++ << 0 << quint64(0);
++
++ // Ensure a data frame arriving mid-fragmentation is rejected: once a message
++ // is fragmented, the frames that follow must use opcode 0.
++ QByteArray firstFragment;
++ firstFragment.append(char(QWebSocketProtocol::OpCodeText));
++ firstFragment.append(char(1));
++ firstFragment.append("a");
++ QByteArray secondDataFrame;
++ secondDataFrame.append(char(FIN | QWebSocketProtocol::OpCodeText));
++ secondDataFrame.append(char(1));
++ secondDataFrame.append("b");
++ QTest::newRow("data frame during a fragmented message")
++ << firstFragment + secondDataFrame + textFrame
++ << QWebSocketProtocol::CloseCodeProtocolError << 1 << quint64(0);
++
++ // Ensure even the peer's Close frame is ignored after a failure.
++ QByteArray closeFrame;
++ closeFrame.append(char(FIN | QWebSocketProtocol::OpCodeClose));
++ closeFrame.append(char(2));
++ closeFrame.append(char(0x03));
++ closeFrame.append(char(0xE8));
++ QTest::newRow("close frame after the violation")
++ << strayContinuation + closeFrame << QWebSocketProtocol::CloseCodeProtocolError
++ << 0 << quint64(0);
++
++ // Ensure exceeding the configured message limit stops processing.
++ QTest::newRow("message too big")
++ << textFrame + textFrame << QWebSocketProtocol::CloseCodeTooMuchData
++ << 0 << quint64(4);
++ }
++
++ void tst_DataProcessor::stopProcessingOnError()
++ {
++ QFETCH(QByteArray, data);
++ QFETCH(QWebSocketProtocol::CloseCode, expectedCloseCode);
++ QFETCH(int, expectedTextFrames);
++ QFETCH(quint64, maxMessageSize);
++
++ QWebSocketDataProcessor dataProcessor;
++ dataProcessor.setIdleTimeout(DefaultIdleTimeout);
++ if (maxMessageSize)
++ dataProcessor.setMaxAllowedMessageSize(maxMessageSize);
++
++ QSignalSpy errorSpy(&dataProcessor, &QWebSocketDataProcessor::errorEncountered);
++ QSignalSpy textFrameSpy(&dataProcessor, &QWebSocketDataProcessor::textFrameReceived);
++ QSignalSpy textMessageSpy(&dataProcessor, &QWebSocketDataProcessor::textMessageReceived);
++ QSignalSpy closeSpy(&dataProcessor, &QWebSocketDataProcessor::closeReceived);
++
++ QBuffer buffer;
++ buffer.setData(data);
++ buffer.open(QIODevice::ReadOnly);
++
++ // the violating frame is followed by a well-formed text frame in the same
++ // buffer; processing must stop at the violation
++ QVERIFY(!dataProcessor.process(&buffer));
++ QCOMPARE(errorSpy.size(), 1);
++ QCOMPARE(errorSpy.first().at(0).value<QWebSocketProtocol::CloseCode>(), expectedCloseCode);
++ QCOMPARE(textFrameSpy.size(), expectedTextFrames);
++ QCOMPARE(textMessageSpy.size(), 0);
++
++ // no further data is parsed for a connection that has failed
++ QVERIFY(!dataProcessor.process(&buffer));
++ QCOMPARE(errorSpy.size(), 1);
++ QCOMPARE(textFrameSpy.size(), expectedTextFrames);
++ QCOMPARE(textMessageSpy.size(), 0);
++ QCOMPARE(closeSpy.size(), 0);
++ buffer.close();
++
++ // ensure processor is usable again after clear()
++ dataProcessor.clear();
++ QByteArray goodFrame;
++ goodFrame.append(char(FIN | QWebSocketProtocol::OpCodeText));
++ goodFrame.append(char(2));
++ goodFrame.append("ok");
++ QBuffer reopened;
++ reopened.setData(goodFrame);
++ reopened.open(QIODevice::ReadOnly);
++ QVERIFY(dataProcessor.process(&reopened));
++ QCOMPARE(textMessageSpy.size(), 1);
++ QCOMPARE(textMessageSpy.first().at(0).toString(), QStringLiteral("ok"));
++ }
++
++ void tst_DataProcessor::stopProcessingOnTimeout()
++ {
++ QWebSocketDataProcessor dataProcessor;
++ dataProcessor.setIdleTimeout(DefaultIdleTimeout);
++
++ QSignalSpy errorSpy(&dataProcessor, &QWebSocketDataProcessor::errorEncountered);
++ QSignalSpy textMessageSpy(&dataProcessor, &QWebSocketDataProcessor::textMessageReceived);
++
++ // a header announcing a 7 byte payload, with no payload yet
++ QByteArray header;
++ header.append(char(FIN | QWebSocketProtocol::OpCodeText));
++ header.append(char(7));
++
++ QBuffer buffer;
++ buffer.setData(header);
++ buffer.open(QIODevice::ReadOnly);
++ QVERIFY(!dataProcessor.process(&buffer));
++ buffer.close();
++
++ QTRY_VERIFY_WITH_TIMEOUT(errorSpy.size(), 7000);
++ QCOMPARE(errorSpy.size(), 1);
++ QCOMPARE(errorSpy.first().at(0).value<QWebSocketProtocol::CloseCode>(),
++ QWebSocketProtocol::CloseCodeGoingAway);
++
++ // the announced payload finally arrives; it must not be parsed as a frame
++ QByteArray payload;
++ payload.append(char(FIN | QWebSocketProtocol::OpCodeText));
++ payload.append(char(5));
++ payload.append("hello");
++
++ QBuffer resumed;
++ resumed.setData(payload);
++ resumed.open(QIODevice::ReadOnly);
++ QVERIFY(!dataProcessor.process(&resumed));
++ QCOMPARE(textMessageSpy.size(), 0);
++ }
++
++ QTEST_MAIN(tst_DataProcessor)
++
++ #include "tst_dataprocessor.moc"