diff -r 000000000000 -r 876b1a06bc25 tests/auto/qpacketprotocol/tst_qpacketprotocol.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/auto/qpacketprotocol/tst_qpacketprotocol.cpp	Wed Aug 25 15:49:42 2010 +0300
@@ -0,0 +1,291 @@
+/****************************************************************************
+**
+** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the Qt Mobility Components.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qpacketprotocol_p.h>
+
+#include <QByteArray>
+#include <QBuffer>
+#include <QLocalServer>
+#include <QLocalSocket>
+
+#include <QtTest/QTest>
+#include <QSignalSpy>
+
+#include <QDebug>
+
+#define QTRY_COMPARE(a,e)                       \
+    for (int _i = 0; _i < 5000; _i += 100) {    \
+        if ((a) == (e)) break;                  \
+        QTest::qWait(100);                      \
+    }                                           \
+    QCOMPARE(a, e)
+
+#define QTRY_VERIFY(a)                       \
+    for (int _i = 0; _i < 5000; _i += 100) {    \
+        if (a) break;                  \
+        QTest::qWait(100);                      \
+    }                                           \
+    QVERIFY(a)
+
+Q_DECLARE_METATYPE(QList<int>)
+
+QTM_USE_NAMESPACE
+class tst_QPacketProtocol : public QObject
+{
+    Q_OBJECT
+
+private slots:
+    void constructor();
+
+    void maximumPacketSize_data();
+    void maximumPacketSize();
+
+    void sendReceive();
+};
+
+void tst_QPacketProtocol::constructor()
+{
+    QByteArray data;
+    QBuffer buffer(&data);
+
+    {
+        QPacketProtocol protocol(&buffer);
+
+        QCOMPARE(protocol.device(), (QIODevice*)&buffer);
+    }
+}
+
+#define ROW_FOR_SIZE(x) x << x << (QList<int>() << 1 << 1 << (x - 4) << 1 << (x - 3) << 0)
+
+void tst_QPacketProtocol::maximumPacketSize_data()
+{
+    QTest::addColumn<qint32>("maxPacketSize");
+    QTest::addColumn<qint32>("actualMaxPacketSize");
+    QTest::addColumn<QList<int> >("packetSizes");    // pairs of packetSize, readCount
+
+#ifndef Q_OS_WIN
+    //Don't perform these tests under windows
+    //because they time out due to QLocalSocket
+    //being too slow.  Packet sizes typically
+    //won't be this large anyway.
+    QTest::newRow("10MB") << ROW_FOR_SIZE(10 * 1024 * 1024);
+    QTest::newRow("1MB") << ROW_FOR_SIZE(1024 * 1024);
+#endif
+    QTest::newRow("100kB") << ROW_FOR_SIZE(100 * 1024);
+    QTest::newRow("10kB") << ROW_FOR_SIZE(10 * 1024);
+    QTest::newRow("1kB") << ROW_FOR_SIZE(1024);
+    QTest::newRow("100B") << ROW_FOR_SIZE(100);
+    QTest::newRow("10B") << ROW_FOR_SIZE(10);
+    QTest::newRow("5B") << ROW_FOR_SIZE(5);
+    QTest::newRow("4B") << 4 << 0x7FFFFFFF << QList<int>();
+    QTest::newRow("0B") << 0 << 0x7FFFFFFF << QList<int>();
+    QTest::newRow("-1") << -1 << 0x7FFFFFFF << QList<int>();
+}
+
+void tst_QPacketProtocol::maximumPacketSize()
+{
+    QFETCH(qint32, maxPacketSize);
+    QFETCH(qint32, actualMaxPacketSize);
+    QFETCH(QList<int>, packetSizes);
+
+    QLocalServer server;
+    server.listen("tst_QPacketProtocol");
+
+    QLocalSocket socket;
+    socket.connectToServer("tst_QPacketProtocol", QIODevice::WriteOnly);
+
+    bool timedOut;
+    server.waitForNewConnection(5000, &timedOut);
+    QVERIFY(!timedOut);
+
+    QLocalSocket *serverSocket = server.nextPendingConnection();
+
+    QVERIFY(serverSocket);
+
+    QPacketProtocol writeProtocol(&socket);
+    QPacketProtocol readProtocol(serverSocket);
+
+    readProtocol.setMaximumPacketSize(maxPacketSize);
+
+    QCOMPARE(readProtocol.maximumPacketSize(), actualMaxPacketSize);
+
+    if (maxPacketSize == actualMaxPacketSize) {
+        QVERIFY(!packetSizes.isEmpty());
+        QVERIFY(packetSizes.count() % 2 == 0);
+
+        while (!packetSizes.isEmpty()) {
+            int packetSize = packetSizes.takeFirst();
+            int readCount = packetSizes.takeFirst();
+
+            QByteArray b(packetSize, 'T');
+            QPacket sendPacket;
+            sendPacket.writeRawData(b.constData(), packetSize);
+            writeProtocol.send(sendPacket);
+
+            QSignalSpy spy(&readProtocol, SIGNAL(readyRead()));
+            QSignalSpy invalidSpy(&readProtocol, SIGNAL(invalidPacket()));
+
+            QTRY_COMPARE(spy.count(), readCount);
+            QTRY_COMPARE(invalidSpy.count(), 1 - readCount);
+
+            QCOMPARE(readProtocol.packetsAvailable(), qint64(readCount));
+
+            QPacket packet = readProtocol.read();
+
+            QCOMPARE(packet.device()->size(), qint64(readCount * packetSize));
+        }
+    }
+}
+
+void tst_QPacketProtocol::sendReceive()
+{
+    QLocalServer server;
+    server.listen("tst_QPacketProtocol");
+
+    QLocalSocket socket;
+    socket.connectToServer("tst_QPacketProtocol", QIODevice::WriteOnly);
+
+    bool timedOut;
+    server.waitForNewConnection(5000, &timedOut);
+    QVERIFY(!timedOut);
+
+    QLocalSocket *serverSocket = server.nextPendingConnection();
+    QVERIFY(serverSocket);
+
+    QPacketProtocol writeProtocol(&socket);
+    QPacketProtocol readProtocol(serverSocket);
+
+    QByteArray dataString("Data string");
+
+    // Test sending with ::send(QPacket).
+    for (int i = 1; i <= 10; ++i) {
+        QSignalSpy writeSpy(&writeProtocol, SIGNAL(packetWritten()));
+        QSignalSpy readSpy(&readProtocol, SIGNAL(readyRead()));
+
+        // Test sending an empty packet.
+        writeProtocol.send(QPacket());
+
+        QPacket sendPacket;
+        sendPacket << dataString;
+        for (int j = 0; j < i; ++j)
+            writeProtocol.send(sendPacket);
+
+        QTRY_COMPARE(writeSpy.count(), i);
+        QTRY_COMPARE(readSpy.count(), i);
+
+        QCOMPARE(readProtocol.packetsAvailable(), qint64(i));
+        for (int j = 0; j < i; ++j) {
+            QPacket packet = readProtocol.read();
+            QByteArray r;
+            packet >> r;
+            QCOMPARE(r, dataString);
+        }
+
+        QCOMPARE(readProtocol.packetsAvailable(), qint64(0));
+    }
+
+    // Test sending with ::send() << var.
+    for (int i = 1; i <= 10; ++i) {
+        QSignalSpy writeSpy(&writeProtocol, SIGNAL(packetWritten()));
+        QSignalSpy readSpy(&readProtocol, SIGNAL(readyRead()));
+
+        // Test sending an empty packet.
+        writeProtocol.send();
+
+        for (int j = 0; j < i; ++j)
+            writeProtocol.send() << dataString.constData();
+
+        QTRY_COMPARE(writeSpy.count(), i);
+        QTRY_COMPARE(readSpy.count(), i);
+
+        QCOMPARE(readProtocol.packetsAvailable(), qint64(i));
+        for (int j = 0; j < i; ++j) {
+            QPacket packet = readProtocol.read();
+            char *string;
+            packet >> string;
+            QByteArray r(string);
+            QCOMPARE(r, dataString);
+        }
+
+        QCOMPARE(readProtocol.packetsAvailable(), qint64(0));
+    }
+
+    // Test ::clear().
+    for (int i = 1; i <= 10; ++i) {
+        QByteArray b("Data string");
+
+        QSignalSpy writeSpy(&writeProtocol, SIGNAL(packetWritten()));
+        QSignalSpy readSpy(&readProtocol, SIGNAL(readyRead()));
+
+        QPacket sendPacket;
+        sendPacket << b;
+        for (int j = 0; j < i; ++j)
+            writeProtocol.send(sendPacket);
+
+        QTRY_COMPARE(writeSpy.count(), i);
+        QTRY_COMPARE(readSpy.count(), i);
+
+        QCOMPARE(readProtocol.packetsAvailable(), qint64(i));
+
+        readProtocol.clear();
+
+        QCOMPARE(readProtocol.packetsAvailable(), qint64(0));
+    }
+
+    {
+        QSignalSpy writeSpy(&writeProtocol, SIGNAL(packetWritten()));
+        QSignalSpy readSpy(&readProtocol, SIGNAL(readyRead()));
+        QSignalSpy closeSpy(serverSocket, SIGNAL(aboutToClose()));
+
+        writeProtocol.send() << dataString.constData();
+
+        serverSocket->close();
+        socket.close();
+
+        QTRY_VERIFY(!closeSpy.isEmpty());
+
+        QTRY_VERIFY(writeSpy.isEmpty());
+        QTRY_VERIFY(readSpy.isEmpty());
+    }
+}
+
+QTEST_MAIN(tst_QPacketProtocol)
+#include "tst_qpacketprotocol.moc"