Long live Qt 4.5!

3 files changed, 478 insertions, 0 deletions

diff --git a/tests/auto/qiodevice/.gitignore b/tests/auto/qiodevice/.gitignore
new file mode 100644
index 0000000000..e503843519
--- /dev/null
+++ b/tests/auto/qiodevice/.gitignore
@@ -0,0 +1,2 @@
+tst_qiodevice
+peektestfile
diff --git a/tests/auto/qiodevice/qiodevice.pro b/tests/auto/qiodevice/qiodevice.pro
new file mode 100644
index 0000000000..e2864e86bc
--- /dev/null
+++ b/tests/auto/qiodevice/qiodevice.pro
@@ -0,0 +1,18 @@
+load(qttest_p4)
+SOURCES  += tst_qiodevice.cpp
+
+QT = core network
+
+wince*: {
+   addFiles.sources = tst_qiodevice.cpp
+   addFiles.path = .
+   DEPLOYMENT += addFiles
+   DEFINES += SRCDIR=\\\"\\\"
+   !wince50standard-x86-msvc2005: DEFINES += WINCE_EMULATOR_TEST=1
+} else {
+   DEFINES += SRCDIR=\\\"$$PWD/\\\"
+   contains(QT_CONFIG, qt3support):QT += qt3support
+}
+MOC_DIR=tmp
+
+
diff --git a/tests/auto/qiodevice/tst_qiodevice.cpp b/tests/auto/qiodevice/tst_qiodevice.cpp
new file mode 100644
index 0000000000..6a8ff73687
--- /dev/null
+++ b/tests/auto/qiodevice/tst_qiodevice.cpp
@@ -0,0 +1,458 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 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 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QtCore/QtCore>
+#include <QtNetwork/QtNetwork>
+#include <QtTest/QtTest>
+
+#include "../network-settings.h"
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+class tst_QIODevice : public QObject
+{
+    Q_OBJECT
+
+public:
+    tst_QIODevice();
+    virtual ~tst_QIODevice();
+
+
+public slots:
+    void init();
+    void cleanup();
+private slots:
+    void getSetCheck();
+    void constructing_QTcpSocket();
+    void constructing_QFile();
+    void read_QByteArray();
+    void unget();
+#if QT_VERSION >= 0x040100
+    void peek();
+#endif // QT_VERSION
+    void getch();
+    void putch();
+
+    void readLine_data();
+    void readLine();
+};
+
+// Testing get/set functions
+void tst_QIODevice::getSetCheck()
+{
+    // OpenMode QIODevice::openMode()
+    // void QIODevice::setOpenMode(OpenMode)
+    class MyIODevice : public QIODevice {
+    public:
+        void setOpenMode(OpenMode openMode) { QIODevice::setOpenMode(openMode); }
+    };
+    QTcpSocket var1;
+    MyIODevice *obj1 = reinterpret_cast<MyIODevice*>(&var1);
+    obj1->setOpenMode(QIODevice::OpenMode(QIODevice::NotOpen));
+    QCOMPARE(QIODevice::OpenMode(QIODevice::NotOpen), obj1->openMode());
+    obj1->setOpenMode(QIODevice::OpenMode(QIODevice::ReadWrite));
+    QCOMPARE(QIODevice::OpenMode(QIODevice::ReadWrite), obj1->openMode());
+}
+
+tst_QIODevice::tst_QIODevice()
+{
+}
+
+tst_QIODevice::~tst_QIODevice()
+{
+
+}
+
+void tst_QIODevice::init()
+{
+}
+
+void tst_QIODevice::cleanup()
+{
+}
+
+//----------------------------------------------------------------------------------
+void tst_QIODevice::constructing_QTcpSocket()
+{
+#if defined(Q_OS_WINCE) && defined(WINCE_EMULATOR_TEST)
+    QSKIP("Networking tests in a WinCE emulator are unstable", SkipAll);
+#endif
+    QTcpSocket socket;
+    QIODevice *device = &socket;
+
+    QVERIFY(!device->isOpen());
+
+    socket.connectToHost("imap.troll.no", 143);
+    QVERIFY(socket.waitForConnected(5000));
+    QVERIFY(device->isOpen());
+
+    while (!device->canReadLine())
+        QVERIFY(device->waitForReadyRead(5000));
+
+    char buf[1024];
+    memset(buf, 0, sizeof(buf));
+    qlonglong lineLength = device->readLine(buf, sizeof(buf));
+    QVERIFY(lineLength > 0);
+    QCOMPARE(socket.pos(), qlonglong(0));
+
+    socket.close();
+    socket.connectToHost("imap.troll.no", 143);
+    QVERIFY(socket.waitForConnected(5000));
+
+    while (!device->canReadLine())
+        QVERIFY(device->waitForReadyRead(5000));
+
+    char buf2[1024];
+    memset(buf2, 0, sizeof(buf2));
+    QCOMPARE(socket.readLine(buf2, sizeof(buf2)), lineLength);
+
+    char *c1 = buf;
+    char *c2 = buf2;
+    while (*c1 && *c2) {
+        QCOMPARE(*c1, *c2);
+        ++c1;
+        ++c2;
+    }
+    QCOMPARE(*c1, *c2);
+}
+
+//----------------------------------------------------------------------------------
+void tst_QIODevice::constructing_QFile()
+{
+    QFile file;
+    QIODevice *device = &file;
+
+    QVERIFY(!device->isOpen());
+
+    file.setFileName(SRCDIR "tst_qiodevice.cpp");
+    QVERIFY(file.open(QFile::ReadOnly));
+    QVERIFY(device->isOpen());
+    QCOMPARE((int) device->openMode(), (int) QFile::ReadOnly);
+
+    char buf[1024];
+    memset(buf, 0, sizeof(buf));
+    qlonglong lineLength = device->readLine(buf, sizeof(buf));
+    QVERIFY(lineLength > 0);
+    QCOMPARE(file.pos(), lineLength);
+
+    file.seek(0);
+    char buf2[1024];
+    memset(buf2, 0, sizeof(buf2));
+    QCOMPARE(file.readLine(buf2, sizeof(buf2)), lineLength);
+
+    char *c1 = buf;
+    char *c2 = buf2;
+    while (*c1 && *c2) {
+        QCOMPARE(*c1, *c2);
+        ++c1;
+        ++c2;
+    }
+    QCOMPARE(*c1, *c2);
+}
+
+
+void tst_QIODevice::read_QByteArray()
+{
+    QFile f(SRCDIR "tst_qiodevice.cpp");
+    f.open(QIODevice::ReadOnly);
+
+    QByteArray b = f.read(10);
+    QCOMPARE(b.length(), 10);
+
+    b = f.read(256);
+    QCOMPARE(b.length(), 256);
+
+    b = f.read(0);
+    QCOMPARE(b.length(), 0);
+}
+
+//--------------------------------------------------------------------
+void tst_QIODevice::unget()
+{
+#if defined(Q_OS_WINCE) && defined(WINCE_EMULATOR_TEST)
+    QSKIP("Networking tests in a WinCE emulator are unstable", SkipAll);
+#endif
+    QBuffer buffer;
+    buffer.open(QBuffer::ReadWrite);
+    buffer.write("ZXCV");
+    buffer.seek(0);
+    QCOMPARE(buffer.read(4), QByteArray("ZXCV"));
+    QCOMPARE(buffer.pos(), qint64(4));
+
+    buffer.ungetChar('a');
+    buffer.ungetChar('b');
+    buffer.ungetChar('c');
+    buffer.ungetChar('d');
+
+    QCOMPARE(buffer.pos(), qint64(0));
+
+    char buf[6];
+    QCOMPARE(buffer.readLine(buf, 5), qint64(4));
+    QCOMPARE(buffer.pos(), qint64(4));
+    QCOMPARE(static_cast<const char*>(buf), "dcba");
+
+    buffer.ungetChar('a');
+    buffer.ungetChar('b');
+    buffer.ungetChar('c');
+    buffer.ungetChar('d');
+
+    QCOMPARE(buffer.pos(), qint64(0));
+
+    for (int i = 0; i < 5; ++i) {
+        buf[0] = '@';
+        buf[1] = '@';
+        QTest::ignoreMessage(QtWarningMsg,
+                              "QIODevice::readLine: Called with maxSize < 2");
+        QCOMPARE(buffer.readLine(buf, 1), qint64(-1));
+        QCOMPARE(buffer.readLine(buf, 2), qint64(i < 4 ? 1 : -1));
+        switch (i) {
+        case 0: QCOMPARE(buf[0], 'd'); break;
+        case 1: QCOMPARE(buf[0], 'c'); break;
+        case 2: QCOMPARE(buf[0], 'b'); break;
+        case 3: QCOMPARE(buf[0], 'a'); break;
+        case 4: QCOMPARE(buf[0], '\0'); break;
+        }
+        QCOMPARE(buf[1], i < 4 ? '\0' : '@');
+    }
+
+    buffer.ungetChar('\n');
+    QCOMPARE(buffer.readLine(), QByteArray("\n"));
+
+    buffer.seek(1);
+    buffer.readLine(buf, 3);
+    QCOMPARE(static_cast<const char*>(buf), "XC");
+
+    buffer.seek(4);
+    buffer.ungetChar('Q');
+    QCOMPARE(buffer.readLine(buf, 3), qint64(1));
+
+    for (int i = 0; i < 2; ++i) {
+        QTcpSocket socket;
+	QIODevice *dev;
+	QByteArray result;
+	const char *lineResult;
+	if (i == 0) {
+            dev = &buffer;
+            result = QByteArray("ZXCV");
+            lineResult = "ZXCV";
+        } else {
+            socket.connectToHost(QtNetworkSettings::serverName(), 80);
+            socket.write("GET / HTTP/1.0\r\n\r\n");
+            QVERIFY(socket.waitForReadyRead());
+            dev = &socket;
+            result = QByteArray("HTTP");
+            lineResult = "Date";
+	}
+	char ch, ch2;
+	dev->seek(0);
+	dev->getChar(&ch);
+	dev->ungetChar(ch);
+	QCOMPARE(dev->peek(4), result);
+	dev->getChar(&ch);
+	dev->getChar(&ch2);
+	dev->ungetChar(ch2);
+	dev->ungetChar(ch);
+	QCOMPARE(dev->read(1), result.left(1));
+	QCOMPARE(dev->read(3), result.right(3));
+
+        if (i == 0)
+	    dev->seek(0);
+        else
+            dev->readLine();
+        dev->getChar(&ch);
+        dev->ungetChar(ch);
+        dev->readLine(buf, 5);
+        QCOMPARE(static_cast<const char*>(buf), lineResult);
+
+        if (i == 1)
+            socket.close();
+    }
+}
+
+//--------------------------------------------------------------------
+#if QT_VERSION >= 0x040100
+void tst_QIODevice::peek()
+{
+    QBuffer buffer;
+    QFile::remove("peektestfile");
+    QFile file("peektestfile");
+
+    for (int i = 0; i < 2; ++i) {
+	QIODevice *device = i ? (QIODevice *)&file : (QIODevice *)&buffer;
+
+	device->open(QBuffer::ReadWrite);
+	device->write("ZXCV");
+
+	device->seek(0);
+	QCOMPARE(device->peek(4), QByteArray("ZXCV"));
+	QCOMPARE(device->pos(), qint64(0));
+	device->write("ABCDE");
+	device->seek(3);
+	QCOMPARE(device->peek(1), QByteArray("D"));
+	QCOMPARE(device->peek(5), QByteArray("DE"));
+	device->seek(0);
+	QCOMPARE(device->read(4), QByteArray("ABCD"));
+	QCOMPARE(device->pos(), qint64(4));
+
+	device->seek(0);
+	device->write("ZXCV");
+	device->seek(0);
+	char buf[5];
+	buf[4] = 0;
+	device->peek(buf, 4);
+	QCOMPARE(static_cast<const char *>(buf), "ZXCV");
+	QCOMPARE(device->pos(), qint64(0));
+	device->read(buf, 4);
+	QCOMPARE(static_cast<const char *>(buf), "ZXCV");
+	QCOMPARE(device->pos(), qint64(4));
+    }
+    QFile::remove("peektestfile");
+}
+#endif // QT_VERSION
+
+void tst_QIODevice::getch()
+{
+#ifdef QT3_SUPPORT
+    QBuffer buffer;
+    buffer.open(QBuffer::ReadWrite);
+    buffer.write("\xff\x7f\x80\x00", 4);
+    buffer.reset();
+    QCOMPARE(buffer.getch(), 0xff);
+    QCOMPARE(buffer.getch(), 0x7f);
+    QCOMPARE(buffer.getch(), 0x80);
+    QCOMPARE(buffer.getch(), 0x00);
+
+    buffer.ungetch(0x00);
+    buffer.ungetch(0x80);
+    buffer.ungetch(0x7f);
+    buffer.ungetch(0xff);
+
+    QCOMPARE(buffer.getch(), 0xff);
+    QCOMPARE(buffer.getch(), 0x7f);
+    QCOMPARE(buffer.getch(), 0x80);
+    QCOMPARE(buffer.getch(), 0x00);
+#endif
+}
+
+void tst_QIODevice::putch()
+{
+#ifdef QT3_SUPPORT
+    QBuffer buffer;
+    buffer.open(QBuffer::ReadWrite);
+    buffer.putch(0xff);
+    buffer.putch(0x7f);
+    buffer.putch(0x80);
+    buffer.putch(0x00);
+    buffer.reset();
+    QCOMPARE(buffer.getch(), 0xff);
+    QCOMPARE(buffer.getch(), 0x7f);
+    QCOMPARE(buffer.getch(), 0x80);
+    QCOMPARE(buffer.getch(), 0x00);
+#endif
+}
+
+void tst_QIODevice::readLine_data()
+{
+    QTest::addColumn<QByteArray>("data");
+
+    QTest::newRow("0") << QByteArray("\nAA");
+    QTest::newRow("1") << QByteArray("A\nAA");
+
+    QByteArray data(9000, 'A');
+    data[8193] = '\n';
+    QTest::newRow("8194") << data;
+    data[8193] = 'A';
+    data[8192] = '\n';
+    QTest::newRow("8193") << data;
+    data[8192] = 'A';
+    data[8191] = '\n';
+    QTest::newRow("8192") << data;
+    data[8191] = 'A';
+    data[8190] = '\n';
+    QTest::newRow("8191") << data;
+
+    data[5999] = '\n';
+    QTest::newRow("6000") << data;
+
+    data[4095] = '\n';
+    QTest::newRow("4096") << data;
+
+    data[4094] = '\n';
+    data[4095] = 'A';
+    QTest::newRow("4095") << data;
+}
+
+void tst_QIODevice::readLine()
+{
+    QFETCH(QByteArray, data);
+    QBuffer buffer(&data);
+    QVERIFY(buffer.open(QIODevice::ReadWrite));
+    QVERIFY(buffer.canReadLine());
+
+    int linelen = data.indexOf('\n') + 1;
+    QByteArray line;
+    line.reserve(linelen + 100);
+
+    int result = buffer.readLine(line.data(), linelen + 100);
+    QCOMPARE(result, linelen);
+
+    // try the exact length of the line (plus terminating \0)
+    QVERIFY(buffer.seek(0));
+    result = buffer.readLine(line.data(), linelen + 1);
+    QCOMPARE(result, linelen);
+
+#if QT_VERSION >= 0x0402000
+    // try with a line length limit
+    QVERIFY(buffer.seek(0));
+    line = buffer.readLine(linelen + 100);
+    QCOMPARE(line.size(), linelen);
+
+    // try without a length limit
+    QVERIFY(buffer.seek(0));
+    line = buffer.readLine();
+    QCOMPARE(line.size(), linelen);
+#endif
+}
+
+QTEST_MAIN(tst_QIODevice)
+#include "tst_qiodevice.moc"