summaryrefslogtreecommitdiffstats
path: root/tests/auto/qtcpsocket/tst_qtcpsocket.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tests/auto/qtcpsocket/tst_qtcpsocket.cpp')
-rw-r--r--tests/auto/qtcpsocket/tst_qtcpsocket.cpp2345
1 files changed, 2345 insertions, 0 deletions
diff --git a/tests/auto/qtcpsocket/tst_qtcpsocket.cpp b/tests/auto/qtcpsocket/tst_qtcpsocket.cpp
new file mode 100644
index 0000000..1e7cc48
--- /dev/null
+++ b/tests/auto/qtcpsocket/tst_qtcpsocket.cpp
@@ -0,0 +1,2345 @@
+/****************************************************************************
+**
+** 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$
+**
+****************************************************************************/
+
+
+#ifdef _WIN32
+#include <winsock2.h>
+#else
+#include <sys/types.h>
+#include <sys/socket.h>
+#define SOCKET int
+#define INVALID_SOCKET -1
+#endif
+
+#include <qplatformdefs.h>
+
+#include <QtTest/QtTest>
+
+#include <QAuthenticator>
+#include <QCoreApplication>
+#include <QEventLoop>
+#include <QFile>
+#include <QHostAddress>
+#include <QHostInfo>
+#include <QMap>
+#include <QMessageBox>
+#include <QPointer>
+#include <QProcess>
+#include <QPushButton>
+#include <QStringList>
+#include <QTcpServer>
+#include <QTcpSocket>
+#ifndef QT_NO_OPENSSL
+#include <QSslSocket>
+#endif
+#include <QTextStream>
+#include <QThread>
+#include <QTime>
+#include <QTimer>
+#include <QDebug>
+#ifndef TEST_QNETWORK_PROXY
+#define TEST_QNETWORK_PROXY
+#endif
+#ifdef TEST_QNETWORK_PROXY
+# include <QNetworkProxy>
+#endif
+
+#ifdef Q_OS_LINUX
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
+#include "../network-settings.h"
+
+Q_DECLARE_METATYPE(QAbstractSocket::SocketError)
+Q_DECLARE_METATYPE(QAbstractSocket::SocketState)
+Q_DECLARE_METATYPE(QNetworkProxy)
+Q_DECLARE_METATYPE(QList<QNetworkProxy>)
+
+//TESTED_CLASS=
+//TESTED_FILES=
+
+QT_FORWARD_DECLARE_CLASS(QTcpSocket)
+
+class tst_QTcpSocket : public QObject
+{
+ Q_OBJECT
+
+public:
+ tst_QTcpSocket();
+ virtual ~tst_QTcpSocket();
+
+ static void enterLoop(int secs)
+ {
+ ++loopLevel;
+ QTestEventLoop::instance().enterLoop(secs);
+ --loopLevel;
+ }
+ static void exitLoop()
+ {
+ // Safe exit - if we aren't in an event loop, don't
+ // exit one.
+ if (loopLevel > 0)
+ QTestEventLoop::instance().exitLoop();
+ }
+ static bool timeout()
+ {
+ return QTestEventLoop::instance().timeout();
+ }
+
+public slots:
+ void initTestCase_data();
+ void init();
+ void cleanup();
+private slots:
+ void constructing();
+ void setInvalidSocketDescriptor();
+ void setSocketDescriptor();
+ void socketDescriptor();
+ void blockingIMAP();
+ void nonBlockingIMAP();
+ void hostNotFound();
+ void timeoutConnect();
+ void delayedClose();
+ void partialRead();
+ void unget();
+ void readAllAfterClose();
+ void openCloseOpenClose();
+ void connectDisconnectConnectDisconnect();
+ void disconnectWhileConnecting_data();
+ void disconnectWhileConnecting();
+ void disconnectWhileConnectingNoEventLoop_data();
+ void disconnectWhileConnectingNoEventLoop();
+ void disconnectWhileLookingUp_data();
+ void disconnectWhileLookingUp();
+ void downloadBigFile();
+ void readLine();
+ void readLineString();
+ void readChunks();
+ void waitForBytesWritten();
+ void waitForReadyRead();
+ void flush();
+ void synchronousApi();
+ void dontCloseOnTimeout();
+ void recursiveReadyRead();
+ void atEnd();
+ void socketInAThread();
+ void socketsInThreads();
+ void waitForReadyReadInASlot();
+ void remoteCloseError();
+ void openMessageBoxInErrorSlot();
+#ifndef Q_OS_WIN
+ void connectToLocalHostNoService();
+#endif
+ void waitForConnectedInHostLookupSlot();
+#ifndef Q_OS_WIN
+ void waitForConnectedInHostLookupSlot2();
+#endif
+ void readyReadSignalsAfterWaitForReadyRead();
+#ifdef Q_OS_LINUX
+ void linuxKernelBugLocalSocket();
+#endif
+ void abortiveClose();
+ void localAddressEmptyOnBSD();
+ void zeroAndMinusOneReturns();
+ void connectionRefused();
+ void suddenRemoteDisconnect_data();
+ void suddenRemoteDisconnect();
+ void connectToMultiIP();
+ void moveToThread0();
+ void increaseReadBufferSize();
+#ifdef TEST_QNETWORK_PROXY
+ void invalidProxy_data();
+ void invalidProxy();
+ void proxyFactory_data();
+ void proxyFactory();
+#endif
+
+protected slots:
+ void nonBlockingIMAP_hostFound();
+ void nonBlockingIMAP_connected();
+ void nonBlockingIMAP_closed();
+ void nonBlockingIMAP_readyRead();
+ void nonBlockingIMAP_bytesWritten(qint64);
+ void readRegularFile_readyRead();
+ void exitLoopSlot();
+ void downloadBigFileSlot();
+ void recursiveReadyReadSlot();
+ void waitForReadyReadInASlotSlot();
+ void messageBoxSlot();
+ void hostLookupSlot();
+ void abortiveClose_abortSlot();
+ void remoteCloseErrorSlot();
+ void proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *auth);
+
+private:
+ QTcpSocket *newSocket() const;
+ QTcpSocket *nonBlockingIMAP_socket;
+ QStringList nonBlockingIMAP_data;
+ qint64 nonBlockingIMAP_totalWritten;
+
+ QTcpSocket *tmpSocket;
+ qint64 bytesAvailable;
+ qint64 expectedLength;
+ bool readingBody;
+ QTime timer;
+
+ mutable int proxyAuthCalled;
+
+ bool gotClosedSignal;
+ int numConnections;
+ static int loopLevel;
+};
+
+enum ProxyTests {
+ NoProxy = 0x00,
+ Socks5Proxy = 0x01,
+ HttpProxy = 0x02,
+ TypeMask = 0x0f,
+
+ NoAuth = 0x00,
+ AuthBasic = 0x10,
+ AuthNtlm = 0x20,
+ AuthMask = 0xf0
+};
+
+int tst_QTcpSocket::loopLevel = 0;
+
+tst_QTcpSocket::tst_QTcpSocket()
+{
+ tmpSocket = 0;
+}
+
+tst_QTcpSocket::~tst_QTcpSocket()
+{
+
+}
+
+void tst_QTcpSocket::initTestCase_data()
+{
+ QTest::addColumn<bool>("setProxy");
+ QTest::addColumn<int>("proxyType");
+ QTest::addColumn<bool>("ssl");
+
+ qDebug() << QtNetworkSettings::serverName();
+ QTest::newRow("WithoutProxy") << false << 0 << false;
+#ifdef TEST_QNETWORK_PROXY
+ QTest::newRow("WithSocks5Proxy") << true << int(Socks5Proxy) << false;
+ QTest::newRow("WithSocks5ProxyAuth") << true << int(Socks5Proxy | AuthBasic) << false;
+
+ QTest::newRow("WithHttpProxy") << true << int(HttpProxy) << false;
+ QTest::newRow("WithHttpProxyBasicAuth") << true << int(HttpProxy | AuthBasic) << false;
+// QTest::newRow("WithHttpProxyNtlmAuth") << true << int(HttpProxy | AuthNtlm) << false;
+#endif
+#ifndef QT_NO_OPENSSL
+ QTest::newRow("WithoutProxy SSL") << false << 0 << true;
+#ifdef TEST_QNETWORK_PROXY
+ QTest::newRow("WithSocks5Proxy SSL") << true << int(Socks5Proxy) << true;
+ QTest::newRow("WithSocks5AuthProxy SSL") << true << int(Socks5Proxy | AuthBasic) << true;
+
+ QTest::newRow("WithHttpProxy SSL") << true << int(HttpProxy) << true;
+ QTest::newRow("WithHttpProxyBasicAuth SSL") << true << int(HttpProxy | AuthBasic) << true;
+// QTest::newRow("WithHttpProxyNtlmAuth SSL") << true << int(HttpProxy | AuthNtlm) << true;
+#endif
+#endif
+}
+
+void tst_QTcpSocket::init()
+{
+ QFETCH_GLOBAL(bool, setProxy);
+ if (setProxy) {
+#ifdef TEST_QNETWORK_PROXY
+ QFETCH_GLOBAL(int, proxyType);
+ QString fluke = QHostInfo::fromName(QtNetworkSettings::serverName()).addresses().first().toString();
+ QNetworkProxy proxy;
+
+ switch (proxyType) {
+ case Socks5Proxy:
+ proxy = QNetworkProxy(QNetworkProxy::Socks5Proxy, fluke, 1080);
+ break;
+
+ case Socks5Proxy | AuthBasic:
+ proxy = QNetworkProxy(QNetworkProxy::Socks5Proxy, fluke, 1081);
+ break;
+
+ case HttpProxy | NoAuth:
+ proxy = QNetworkProxy(QNetworkProxy::HttpProxy, fluke, 3128);
+ break;
+
+ case HttpProxy | AuthBasic:
+ proxy = QNetworkProxy(QNetworkProxy::HttpProxy, fluke, 3129);
+ break;
+
+ case HttpProxy | AuthNtlm:
+ proxy = QNetworkProxy(QNetworkProxy::HttpProxy, fluke, 3130);
+ break;
+ }
+ QNetworkProxy::setApplicationProxy(proxy);
+#endif
+ }
+}
+
+QTcpSocket *tst_QTcpSocket::newSocket() const
+{
+ QTcpSocket *socket;
+#ifndef QT_NO_OPENSSL
+ QFETCH_GLOBAL(bool, ssl);
+ socket = ssl ? new QSslSocket : new QTcpSocket;
+#else
+ socket = new QTcpSocket;
+#endif
+
+ proxyAuthCalled = 0;
+ connect(socket, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
+ SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
+ Qt::DirectConnection);
+ return socket;
+}
+
+void tst_QTcpSocket::cleanup()
+{
+#ifdef TEST_QNETWORK_PROXY
+ QNetworkProxy::setApplicationProxy(QNetworkProxy::DefaultProxy);
+#endif
+}
+
+void tst_QTcpSocket::proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *auth)
+{
+ ++proxyAuthCalled;
+ auth->setUser("qsockstest");
+ auth->setPassword("password");
+}
+
+//----------------------------------------------------------------------------------
+
+void tst_QTcpSocket::constructing()
+{
+ QTcpSocket *socket = newSocket();
+
+ // Check the initial state of the QTcpSocket.
+ QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
+ QVERIFY(socket->isSequential());
+ QVERIFY(!socket->isOpen());
+ QVERIFY(!socket->isValid());
+ QCOMPARE(socket->socketType(), QTcpSocket::TcpSocket);
+
+ char c;
+ QTest::ignoreMessage(QtWarningMsg, "QIODevice::getChar: Closed device");
+ QCOMPARE(socket->getChar(&c), false);
+ QCOMPARE((int) socket->bytesAvailable(), 0);
+ QCOMPARE(socket->canReadLine(), false);
+ QCOMPARE(socket->readLine(), QByteArray());
+ QCOMPARE(socket->socketDescriptor(), -1);
+ QCOMPARE((int) socket->localPort(), 0);
+ QVERIFY(socket->localAddress() == QHostAddress());
+ QCOMPARE((int) socket->peerPort(), 0);
+ QVERIFY(socket->peerAddress() == QHostAddress());
+ QCOMPARE(socket->error(), QTcpSocket::UnknownSocketError);
+ QCOMPARE(socket->errorString(), QString("Unknown error"));
+
+ // Check the state of the socket layer?
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+
+void tst_QTcpSocket::setInvalidSocketDescriptor()
+{
+ QTcpSocket *socket = newSocket();
+ QCOMPARE(socket->socketDescriptor(), -1);
+ QVERIFY(!socket->setSocketDescriptor(-5, QTcpSocket::UnconnectedState));
+ QCOMPARE(socket->socketDescriptor(), -1);
+
+ QCOMPARE(socket->error(), QTcpSocket::UnsupportedSocketOperationError);
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+
+void tst_QTcpSocket::setSocketDescriptor()
+{
+ QFETCH_GLOBAL(bool, setProxy);
+ if (setProxy)
+ return; // this test doesn't make sense with proxies
+
+#ifdef Q_OS_WIN
+ // need the dummy to ensure winsock is started
+ QTcpSocket *dummy = newSocket();
+ dummy->connectToHost(QtNetworkSettings::serverName(), 143);
+ QVERIFY(dummy->waitForConnected());
+
+ SOCKET sock = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+ if (sock == INVALID_SOCKET) {
+ qErrnoWarning(WSAGetLastError(), "INVALID_SOCKET");
+ }
+#else
+ SOCKET sock = ::socket(AF_INET, SOCK_STREAM, 0);
+#endif
+
+ QVERIFY(sock != INVALID_SOCKET);
+ QTcpSocket *socket = newSocket();
+ QVERIFY(socket->setSocketDescriptor(sock, QTcpSocket::UnconnectedState));
+ QCOMPARE(socket->socketDescriptor(), (int)sock);
+
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ QCOMPARE(socket->state(), QTcpSocket::HostLookupState);
+ QCOMPARE(socket->socketDescriptor(), (int)sock);
+ QVERIFY(socket->waitForConnected(10000));
+ QCOMPARE(socket->socketDescriptor(), (int)sock);
+ delete socket;
+#ifdef Q_OS_WIN
+ delete dummy;
+#endif
+}
+
+//----------------------------------------------------------------------------------
+
+void tst_QTcpSocket::socketDescriptor()
+{
+ QTcpSocket *socket = newSocket();
+
+ QCOMPARE(socket->socketDescriptor(), -1);
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ QVERIFY((socket->state() == QAbstractSocket::HostLookupState && socket->socketDescriptor() == -1) ||
+ (socket->state() == QAbstractSocket::ConnectingState && socket->socketDescriptor() != -1));
+ QVERIFY(socket->waitForConnected(10000));
+ QVERIFY(socket->state() == QAbstractSocket::ConnectedState);
+ QVERIFY(socket->socketDescriptor() != -1);
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+
+void tst_QTcpSocket::blockingIMAP()
+{
+ QTcpSocket *socket = newSocket();
+
+ // Connect
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ QVERIFY(socket->waitForConnected(10000));
+ QCOMPARE(socket->state(), QTcpSocket::ConnectedState);
+ QVERIFY(socket->isValid());
+
+ // Read greeting
+ QVERIFY(socket->waitForReadyRead(5000));
+ QString s = socket->readLine();
+ // only test if an OK was returned, to make the test compatible between different
+ // IMAP server versions
+ QCOMPARE(s.left(4).toLatin1().constData(), "* OK");
+
+ // Write NOOP
+ QCOMPARE((int) socket->write("1 NOOP\r\n", 8), 8);
+ QCOMPARE((int) socket->write("2 NOOP\r\n", 8), 8);
+
+ if (!socket->canReadLine())
+ QVERIFY(socket->waitForReadyRead(5000));
+
+ // Read response
+ s = socket->readLine();
+ QCOMPARE(s.toLatin1().constData(), "1 OK Completed\r\n");
+
+ // Write a third NOOP to verify that write doesn't clear the read buffer
+ QCOMPARE((int) socket->write("3 NOOP\r\n", 8), 8);
+
+ // Read second response
+ if (!socket->canReadLine())
+ QVERIFY(socket->waitForReadyRead(5000));
+ s = socket->readLine();
+ QCOMPARE(s.toLatin1().constData(), "2 OK Completed\r\n");
+
+ // Read third response
+ if (!socket->canReadLine())
+ QVERIFY(socket->waitForReadyRead(5000));
+ s = socket->readLine();
+ QCOMPARE(s.toLatin1().constData(), "3 OK Completed\r\n");
+
+
+ // Write LOGOUT
+ QCOMPARE((int) socket->write("4 LOGOUT\r\n", 10), 10);
+
+ if (!socket->canReadLine())
+ QVERIFY(socket->waitForReadyRead(5000));
+
+ // Read two lines of respose
+ s = socket->readLine();
+ QCOMPARE(s.toLatin1().constData(), "* BYE LOGOUT received\r\n");
+
+ if (!socket->canReadLine())
+ QVERIFY(socket->waitForReadyRead(5000));
+
+ s = socket->readLine();
+ QCOMPARE(s.toLatin1().constData(), "4 OK Completed\r\n");
+
+ // Close the socket
+ socket->close();
+
+ // Check that it's closed
+ QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+
+void tst_QTcpSocket::hostNotFound()
+{
+ QTcpSocket *socket = newSocket();
+
+ socket->connectToHost("nosuchserver.troll.no", 80);
+ QVERIFY(!socket->waitForConnected());
+ QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
+ QCOMPARE(int(socket->error()), int(QTcpSocket::HostNotFoundError));
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+
+void tst_QTcpSocket::timeoutConnect()
+{
+ QTcpSocket *socket = newSocket();
+
+ // Outgoing port 53 is firewalled in the Oslo office.
+ socket->connectToHost("cisco.com", 53);
+ QVERIFY(!socket->waitForConnected(200));
+ QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
+ QCOMPARE(int(socket->error()), int(QTcpSocket::SocketTimeoutError));
+
+ socket->connectToHost("cisco.com", 53);
+ QTest::qSleep(50);
+ socket->abort();
+ QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
+ QCOMPARE(socket->openMode(), QIODevice::NotOpen);
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+
+void tst_QTcpSocket::nonBlockingIMAP()
+{
+ QTcpSocket *socket = newSocket();
+ connect(socket, SIGNAL(hostFound()), SLOT(nonBlockingIMAP_hostFound()));
+ connect(socket, SIGNAL(connected()), SLOT(nonBlockingIMAP_connected()));
+ connect(socket, SIGNAL(disconnected()), SLOT(nonBlockingIMAP_closed()));
+ connect(socket, SIGNAL(bytesWritten(qint64)), SLOT(nonBlockingIMAP_bytesWritten(qint64)));
+ connect(socket, SIGNAL(readyRead()), SLOT(nonBlockingIMAP_readyRead()));
+ nonBlockingIMAP_socket = socket;
+
+ // Connect
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ QVERIFY(socket->state() == QTcpSocket::HostLookupState ||
+ socket->state() == QTcpSocket::ConnectingState);
+
+ enterLoop(30);
+ if (timeout()) {
+ QFAIL("Timed out");
+ }
+
+ if (socket->state() == QTcpSocket::ConnectingState) {
+ enterLoop(30);
+ if (timeout()) {
+ QFAIL("Timed out");
+ }
+ }
+
+ QCOMPARE(socket->state(), QTcpSocket::ConnectedState);
+
+ enterLoop(30);
+ if (timeout()) {
+ QFAIL("Timed out");
+ }
+
+ // Read greeting
+ QVERIFY(!nonBlockingIMAP_data.isEmpty());
+// QCOMPARE(nonBlockingIMAP_data.at(0).toLatin1().constData(),
+// "* OK fluke Cyrus IMAP4 v2.2.12 server ready\r\n");
+ QCOMPARE(nonBlockingIMAP_data.at(0).left(4).toLatin1().constData(), "* OK");
+ nonBlockingIMAP_data.clear();
+
+ nonBlockingIMAP_totalWritten = 0;
+
+ // Write NOOP
+ QCOMPARE((int) socket->write("1 NOOP\r\n", 8), 8);
+
+
+ enterLoop(30);
+ if (timeout()) {
+ QFAIL("Timed out");
+ }
+
+ QVERIFY(nonBlockingIMAP_totalWritten == 8);
+
+
+ enterLoop(30);
+ if (timeout()) {
+ QFAIL("Timed out");
+ }
+
+
+ // Read response
+ QVERIFY(!nonBlockingIMAP_data.isEmpty());
+ QCOMPARE(nonBlockingIMAP_data.at(0).toLatin1().constData(), "1 OK Completed\r\n");
+ nonBlockingIMAP_data.clear();
+
+
+ nonBlockingIMAP_totalWritten = 0;
+
+ // Write LOGOUT
+ QCOMPARE((int) socket->write("2 LOGOUT\r\n", 10), 10);
+
+ enterLoop(30);
+ if (timeout()) {
+ QFAIL("Timed out");
+ }
+
+ QVERIFY(nonBlockingIMAP_totalWritten == 10);
+
+ // Wait for greeting
+ enterLoop(30);
+ if (timeout()) {
+ QFAIL("Timed out");
+ }
+
+ // Read two lines of respose
+ QCOMPARE(nonBlockingIMAP_data.at(0).toLatin1().constData(), "* BYE LOGOUT received\r\n");
+ QCOMPARE(nonBlockingIMAP_data.at(1).toLatin1().constData(), "2 OK Completed\r\n");
+ nonBlockingIMAP_data.clear();
+
+ // Close the socket
+ socket->close();
+
+ // Check that it's closed
+ QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
+
+ delete socket;
+}
+
+void tst_QTcpSocket::nonBlockingIMAP_hostFound()
+{
+ exitLoop();
+}
+
+void tst_QTcpSocket::nonBlockingIMAP_connected()
+{
+ exitLoop();
+}
+
+void tst_QTcpSocket::nonBlockingIMAP_readyRead()
+{
+ while (nonBlockingIMAP_socket->canReadLine())
+ nonBlockingIMAP_data.append(nonBlockingIMAP_socket->readLine());
+
+ exitLoop();
+}
+
+void tst_QTcpSocket::nonBlockingIMAP_bytesWritten(qint64 written)
+{
+ nonBlockingIMAP_totalWritten += written;
+ exitLoop();
+}
+
+void tst_QTcpSocket::nonBlockingIMAP_closed()
+{
+}
+
+//----------------------------------------------------------------------------------
+
+void tst_QTcpSocket::delayedClose()
+{
+ QTcpSocket *socket = newSocket();
+ connect(socket, SIGNAL(connected()), SLOT(nonBlockingIMAP_connected()));
+ connect(socket, SIGNAL(disconnected()), SLOT(exitLoopSlot()));
+
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+
+ enterLoop(30);
+ if (timeout())
+ QFAIL("Timed out");
+
+ QCOMPARE(socket->state(), QTcpSocket::ConnectedState);
+
+ QCOMPARE((int) socket->write("1 LOGOUT\r\n", 10), 10);
+
+ // Add a huge bulk of data to be written after the logout
+ // command. The server will shut down after receiving the LOGOUT,
+ // so this data will not be read. But our close call should
+ // schedule a delayed close because all the data can not be
+ // written in one go.
+ QCOMPARE((int) socket->write(QByteArray(100000, '\n'), 100000), 100000);
+
+ socket->close();
+
+ QCOMPARE((int) socket->state(), (int) QTcpSocket::ClosingState);
+
+ enterLoop(10);
+ if (timeout())
+ QFAIL("Timed out");
+
+ QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+
+void tst_QTcpSocket::partialRead()
+{
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ QVERIFY(socket->waitForConnected(10000));
+ QVERIFY(socket->state() == QTcpSocket::ConnectedState);
+ char buf[512];
+
+// QByteArray greeting = "* OK fluke Cyrus IMAP4 v2.2.12 server ready";
+ QByteArray greeting = "* OK [CAPABILITY IMAP4rev1 UIDPLUS CHILDREN NAMESPACE";
+
+ for (int i = 0; i < 10; i += 2) {
+ while (socket->bytesAvailable() < 2)
+ QVERIFY(socket->waitForReadyRead(5000));
+ QVERIFY(socket->read(buf, 2) == 2);
+ buf[2] = '\0';
+ QCOMPARE((char *)buf, greeting.mid(i, 2).data());
+ }
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+
+void tst_QTcpSocket::unget()
+{
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ QVERIFY(socket->waitForConnected(10000));
+ QVERIFY(socket->state() == QTcpSocket::ConnectedState);
+ char buf[512];
+
+// QByteArray greeting = "* OK fluke Cyrus IMAP4 v2.2.12 server ready";
+ QByteArray greeting = "* OK [CAPABILITY IMAP4rev1 UIDPLUS CHILDREN NAMESPACE";
+
+ for (int i = 0; i < 10; i += 2) {
+ while (socket->bytesAvailable() < 2)
+ QVERIFY(socket->waitForReadyRead(5000));
+ int bA = socket->bytesAvailable();
+ QVERIFY(socket->read(buf, 2) == 2);
+ buf[2] = '\0';
+ QCOMPARE((char *)buf, greeting.mid(i, 2).data());
+ QCOMPARE((int)socket->bytesAvailable(), bA - 2);
+ socket->ungetChar(buf[1]);
+ socket->ungetChar(buf[0]);
+ QCOMPARE((int)socket->bytesAvailable(), bA);
+ QVERIFY(socket->read(buf, 2) == 2);
+ buf[2] = '\0';
+ QCOMPARE((char *)buf, greeting.mid(i, 2).data());
+ }
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::readRegularFile_readyRead()
+{
+ exitLoop();
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::readAllAfterClose()
+{
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ connect(socket, SIGNAL(readyRead()), SLOT(readRegularFile_readyRead()));
+ enterLoop(10);
+ if (timeout())
+ QFAIL("Network operation timed out");
+
+ socket->close();
+ QByteArray array = socket->readAll();
+ QCOMPARE(array.size(), 0);
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::openCloseOpenClose()
+{
+ QTcpSocket *socket = newSocket();
+
+ for (int i = 0; i < 3; ++i) {
+ QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
+ QCOMPARE(int(socket->openMode()), int(QIODevice::NotOpen));
+ QVERIFY(socket->isSequential());
+ QVERIFY(!socket->isOpen());
+ QVERIFY(socket->socketType() == QTcpSocket::TcpSocket);
+
+ char c;
+ QTest::ignoreMessage(QtWarningMsg, "QIODevice::getChar: Closed device");
+ QCOMPARE(socket->getChar(&c), false);
+ QCOMPARE((int) socket->bytesAvailable(), 0);
+ QCOMPARE(socket->canReadLine(), false);
+ QCOMPARE(socket->readLine(), QByteArray());
+ QCOMPARE(socket->socketDescriptor(), -1);
+ QCOMPARE((int) socket->localPort(), 0);
+ QVERIFY(socket->localAddress() == QHostAddress());
+ QCOMPARE((int) socket->peerPort(), 0);
+ QVERIFY(socket->peerAddress() == QHostAddress());
+ QCOMPARE(socket->error(), QTcpSocket::UnknownSocketError);
+ QCOMPARE(socket->errorString(), QString("Unknown error"));
+
+ QVERIFY(socket->state() == QTcpSocket::UnconnectedState);
+
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ QVERIFY(socket->waitForConnected(10000));
+ socket->close();
+ }
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::connectDisconnectConnectDisconnect()
+{
+ QTcpSocket *socket = newSocket();
+
+ for (int i = 0; i < 3; ++i) {
+ QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
+ QVERIFY(socket->socketType() == QTcpSocket::TcpSocket);
+
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ QVERIFY(socket->waitForReadyRead(10000));
+ QCOMPARE(QString::fromLatin1(socket->read(4)), QString("* OK"));
+
+ socket->disconnectFromHost();
+ if (socket->state() != QTcpSocket::UnconnectedState)
+ QVERIFY(socket->waitForDisconnected(10000));
+ QCOMPARE(int(socket->openMode()), int(QIODevice::ReadWrite));
+ }
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::disconnectWhileConnecting_data()
+{
+ QTest::addColumn<QByteArray>("data");
+ QTest::addColumn<bool>("closeDirectly");
+
+ QTest::newRow("without-data") << QByteArray() << false;
+ QTest::newRow("without-data+close") << QByteArray() << true;
+ QTest::newRow("with-data") << QByteArray("Hello, world!") << false;
+ QTest::newRow("with-data+close") << QByteArray("Hello, world!") << true;
+
+ QByteArray bigData(1024*1024, '@');
+ QTest::newRow("with-big-data") << bigData << false;
+ QTest::newRow("with-big-data+close") << bigData << true;
+}
+
+void tst_QTcpSocket::disconnectWhileConnecting()
+{
+ QFETCH(QByteArray, data);
+
+ QTcpServer server;
+ QVERIFY(server.listen(QHostAddress::LocalHost));
+
+ // proceed to the connect-write-disconnect
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost("127.0.0.1", server.serverPort());
+ if (!data.isEmpty())
+ socket->write(data);
+ if (socket->state() == QAbstractSocket::ConnectedState)
+ QSKIP("localhost connections are immediate, test case is invalid", SkipSingle);
+
+ QFETCH(bool, closeDirectly);
+ if (closeDirectly) {
+ socket->close();
+ QCOMPARE(int(socket->openMode()), int(QIODevice::NotOpen));
+ } else {
+ socket->disconnectFromHost();
+ }
+
+ connect(socket, SIGNAL(disconnected()), SLOT(exitLoopSlot()));
+ enterLoop(10);
+ QVERIFY2(!timeout(), "Network timeout");
+ QVERIFY(socket->state() == QAbstractSocket::UnconnectedState);
+ if (!closeDirectly) {
+ QCOMPARE(int(socket->openMode()), int(QIODevice::ReadWrite));
+ socket->close();
+ }
+ QCOMPARE(int(socket->openMode()), int(QIODevice::NotOpen));
+
+ // accept the other side and verify that it was sent properly:
+ QVERIFY(server.hasPendingConnections() || server.waitForNewConnection(0));
+ QTcpSocket *othersocket = server.nextPendingConnection();
+ if (othersocket->state() != QAbstractSocket::UnconnectedState)
+ QVERIFY2(othersocket->waitForDisconnected(10000), "Network timeout");
+ QVERIFY(othersocket->state() == QAbstractSocket::UnconnectedState);
+ QCOMPARE(othersocket->readAll(), data);
+
+ delete socket;
+ delete othersocket;
+}
+
+//----------------------------------------------------------------------------------
+class ReceiverThread: public QThread
+{
+ QTcpServer *server;
+public:
+ int serverPort;
+ bool ok;
+ QByteArray receivedData;
+ volatile bool quit;
+
+ ReceiverThread()
+ : server(0), ok(false), quit(false)
+ { }
+
+ ~ReceiverThread() { wait(); delete server; }
+
+ bool listen()
+ {
+ server = new QTcpServer;
+ if (!server->listen(QHostAddress::LocalHost))
+ return false;
+ serverPort = server->serverPort();
+ server->moveToThread(this);
+ return true;
+ }
+
+protected:
+ void run()
+ {
+ bool timedOut = false;
+ while (!quit) {
+ if (server->waitForNewConnection(500, &timedOut))
+ break;
+ if (!timedOut)
+ return;
+ }
+
+ QTcpSocket *socket = server->nextPendingConnection();
+ while (!quit) {
+ if (socket->waitForDisconnected(500))
+ break;
+ if (socket->error() != QAbstractSocket::SocketTimeoutError)
+ return;
+ }
+
+ if (!quit) {
+ receivedData = socket->readAll();
+ ok = true;
+ }
+ delete socket;
+ delete server;
+ server = 0;
+ }
+};
+
+void tst_QTcpSocket::disconnectWhileConnectingNoEventLoop_data()
+{
+ disconnectWhileConnecting_data();
+}
+
+void tst_QTcpSocket::disconnectWhileConnectingNoEventLoop()
+{
+ QFETCH(QByteArray, data);
+
+ ReceiverThread thread;
+ QVERIFY(thread.listen());
+ thread.start();
+
+ // proceed to the connect-write-disconnect
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost("127.0.0.1", thread.serverPort);
+ if (!data.isEmpty())
+ socket->write(data);
+ if (socket->state() == QAbstractSocket::ConnectedState) {
+ thread.quit = true;
+ thread.wait();
+ QSKIP("localhost connections are immediate, test case is invalid", SkipSingle);
+ }
+
+ QFETCH(bool, closeDirectly);
+ if (closeDirectly) {
+ socket->close();
+ QCOMPARE(int(socket->openMode()), int(QIODevice::NotOpen));
+ } else {
+ socket->disconnectFromHost();
+ }
+
+ QVERIFY2(socket->waitForDisconnected(10000), "Network timeout");
+ QVERIFY(socket->state() == QAbstractSocket::UnconnectedState);
+ if (!closeDirectly) {
+ QCOMPARE(int(socket->openMode()), int(QIODevice::ReadWrite));
+ socket->close();
+ }
+ QCOMPARE(int(socket->openMode()), int(QIODevice::NotOpen));
+ delete socket;
+
+ // check if the other side received everything ok
+ QVERIFY(thread.wait(10000));
+ QVERIFY(thread.ok);
+ QCOMPARE(thread.receivedData, data);
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::disconnectWhileLookingUp_data()
+{
+ QTest::addColumn<bool>("doClose");
+
+ QTest::newRow("disconnect") << false;
+ QTest::newRow("close") << true;
+}
+
+void tst_QTcpSocket::disconnectWhileLookingUp()
+{
+ QFETCH_GLOBAL(bool, setProxy);
+ if (setProxy)
+ return; // we let the proxies do the lookup now
+
+ // just connect and disconnect, then make sure nothing weird happened
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost(QtNetworkSettings::serverName(), 21);
+ QVERIFY(socket->state() == QAbstractSocket::HostLookupState);
+
+ QFETCH(bool, doClose);
+ if (doClose) {
+ socket->close();
+ QVERIFY(socket->openMode() == QIODevice::NotOpen);
+ } else {
+ socket->disconnectFromHost();
+ QVERIFY(socket->openMode() == QIODevice::ReadWrite);
+ }
+
+ // let anything queued happen
+ QEventLoop loop;
+ QTimer::singleShot(50, &loop, SLOT(quit()));
+ loop.exec();
+
+ // recheck
+ if (doClose) {
+ QVERIFY(socket->openMode() == QIODevice::NotOpen);
+ } else {
+ QVERIFY(socket->openMode() == QIODevice::ReadWrite);
+ }
+
+ QVERIFY(socket->state() == QAbstractSocket::UnconnectedState);
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::downloadBigFile()
+{
+ if (tmpSocket)
+ delete tmpSocket;
+ tmpSocket = newSocket();
+
+ connect(tmpSocket, SIGNAL(connected()), SLOT(exitLoopSlot()));
+ connect(tmpSocket, SIGNAL(readyRead()), SLOT(downloadBigFileSlot()));
+
+ tmpSocket->connectToHost(QtNetworkSettings::serverName(), 80);
+
+ enterLoop(30);
+ if (timeout()) {
+ delete tmpSocket;
+ tmpSocket = 0;
+ QFAIL("Network operation timed out");
+ }
+
+ QByteArray hostName = QtNetworkSettings::serverName().toLatin1();
+ QVERIFY(tmpSocket->state() == QAbstractSocket::ConnectedState);
+ QVERIFY(tmpSocket->write("GET /mediumfile HTTP/1.0\r\n") > 0);
+ QVERIFY(tmpSocket->write("HOST: ") > 0);
+ QVERIFY(tmpSocket->write(hostName.data()) > 0);
+ QVERIFY(tmpSocket->write("\r\n") > 0);
+ QVERIFY(tmpSocket->write("\r\n") > 0);
+
+ bytesAvailable = 0;
+ expectedLength = 0;
+ readingBody = false;
+
+ QTime stopWatch;
+ stopWatch.start();
+
+ enterLoop(600);
+ if (timeout()) {
+ delete tmpSocket;
+ tmpSocket = 0;
+ if (bytesAvailable > 0)
+ qDebug("Slow Connection, only downloaded %ld of %d", long(bytesAvailable), 10000281);
+ QFAIL("Network operation timed out");
+ }
+
+ QCOMPARE(bytesAvailable, expectedLength);
+
+ qDebug("\t\t%.1fMB/%.1fs: %.1fMB/s",
+ bytesAvailable / (1024.0 * 1024.0),
+ stopWatch.elapsed() / 1024.0,
+ (bytesAvailable / (stopWatch.elapsed() / 1000.0)) / (1024 * 1024));
+
+ delete tmpSocket;
+ tmpSocket = 0;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::exitLoopSlot()
+{
+ exitLoop();
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::downloadBigFileSlot()
+{
+ if (!readingBody) {
+ while (tmpSocket->canReadLine()) {
+ QByteArray array = tmpSocket->readLine();
+ if (array.startsWith("Content-Length"))
+ expectedLength = array.simplified().split(' ').at(1).toInt();
+ if (array == "\r\n") {
+ readingBody = true;
+ break;
+ }
+ }
+ }
+ if (readingBody) {
+ bytesAvailable += tmpSocket->readAll().size();
+ if (bytesAvailable == expectedLength)
+ exitLoop();
+ }
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::readLine()
+{
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ QVERIFY(socket->waitForConnected(5000));
+
+ while (!socket->canReadLine())
+ QVERIFY(socket->waitForReadyRead(10000));
+
+ char buffer[1024];
+ QCOMPARE(socket->readLine(buffer, sizeof(buffer)), qint64(161));
+
+ // * OK fluke Cyrus IMAP4 v2.2.12 server ready__
+// // 01234567890123456789012345678901234567890123456789
+ QCOMPARE((int) buffer[159], (int) '\r');
+ QCOMPARE((int) buffer[160], (int) '\n');
+ QCOMPARE((int) buffer[161], (int) '\0');
+
+ QCOMPARE(socket->write("1 NOOP\r\n"), qint64(8));
+
+ while (socket->bytesAvailable() < 10)
+ QVERIFY(socket->waitForReadyRead(10000));
+
+ QCOMPARE(socket->readLine(buffer, 11), qint64(10));
+ QCOMPARE((const char *)buffer, "1 OK Compl");
+
+ while (socket->bytesAvailable() < 6)
+ QVERIFY(socket->waitForReadyRead(10000));
+
+ QCOMPARE(socket->readLine(buffer, 11), qint64(6));
+ QCOMPARE((const char *)buffer, "eted\r\n");
+
+ QVERIFY(!socket->waitForReadyRead(100));
+ QCOMPARE(socket->readLine(buffer, sizeof(buffer)), qint64(0));
+ QVERIFY(socket->error() == QAbstractSocket::SocketTimeoutError
+ || socket->error() == QAbstractSocket::RemoteHostClosedError);
+ QCOMPARE(socket->bytesAvailable(), qint64(0));
+
+ socket->close();
+ QCOMPARE(socket->readLine(buffer, sizeof(buffer)), qint64(-1));
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::readLineString()
+{
+ QTcpSocket *socket = newSocket();
+// QByteArray expected("* OK fluke Cyrus IMAP4 v2.2.12 server ready\r\n");
+ QByteArray expected("* OK [CAPABILITY IMAP4 IMAP4rev1 LITERAL+ ID STARTTLS LOGINDISABLED] qt-test-server.qt-test-net Cyrus IMAP4 v2.3.11-Mandriva-RPM-2.3.11-6mdv2008.1 server ready\r\n");
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ QVERIFY(socket->waitForReadyRead(10000));
+
+ QByteArray arr = socket->readLine();
+ QCOMPARE(arr, expected);
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::readChunks()
+{
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ QVERIFY(socket->waitForConnected(10000));
+ QVERIFY(socket->waitForReadyRead(5000));
+
+ char buf[4096];
+ memset(buf, '@', sizeof(buf));
+ qint64 dataLength = socket->read(buf, sizeof(buf));
+ QVERIFY(dataLength > 0);
+
+ QCOMPARE(buf[dataLength - 2], '\r');
+ QCOMPARE(buf[dataLength - 1], '\n');
+ QCOMPARE(buf[dataLength], '@');
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::waitForBytesWritten()
+{
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost(QtNetworkSettings::serverName(), 22);
+ QVERIFY(socket->waitForConnected(10000));
+
+ socket->write(QByteArray(10000, '@'));
+ qint64 toWrite = socket->bytesToWrite();
+ QVERIFY(socket->waitForBytesWritten(5000));
+ QVERIFY(toWrite > socket->bytesToWrite());
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::waitForReadyRead()
+{
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost(QtNetworkSettings::serverName(), 22);
+ socket->waitForReadyRead(0);
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::flush()
+{
+ QTcpSocket *socket = newSocket();
+ socket->flush();
+
+ connect(socket, SIGNAL(connected()), SLOT(exitLoopSlot()));
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ enterLoop(5000);
+ QVERIFY(socket->isOpen());
+
+ socket->write("1 LOGOUT\r\n");
+ QCOMPARE(socket->bytesToWrite(), qint64(10));
+ socket->flush();
+ QCOMPARE(socket->bytesToWrite(), qint64(0));
+ socket->close();
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::synchronousApi()
+{
+ QTcpSocket *ftpSocket = newSocket();
+ ftpSocket->connectToHost(QtNetworkSettings::serverName(), 21);
+ ftpSocket->write("QUIT\r\n");
+ QVERIFY(ftpSocket->waitForDisconnected(10000));
+ QVERIFY(ftpSocket->bytesAvailable() > 0);
+ QByteArray arr = ftpSocket->readAll();
+ QVERIFY(arr.size() > 0);
+ delete ftpSocket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::dontCloseOnTimeout()
+{
+ QTcpServer server;
+#ifdef TEST_QNETWORK_PROXY
+ server.setProxy(QNetworkProxy(QNetworkProxy::NoProxy));
+#endif
+ QVERIFY(server.listen());
+
+ QHostAddress serverAddress = QHostAddress::LocalHost;
+ if (!(server.serverAddress() == QHostAddress::Any))
+ serverAddress = server.serverAddress();
+
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost(serverAddress, server.serverPort());
+ QVERIFY(!socket->waitForReadyRead(100));
+ QCOMPARE(socket->error(), QTcpSocket::SocketTimeoutError);
+ QVERIFY(socket->isOpen());
+
+ QVERIFY(!socket->waitForDisconnected(100));
+ QCOMPARE(socket->error(), QTcpSocket::SocketTimeoutError);
+ QVERIFY(socket->isOpen());
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::recursiveReadyRead()
+{
+ QTcpSocket *smtp = newSocket();
+ connect(smtp, SIGNAL(connected()), SLOT(exitLoopSlot()));
+ connect(smtp, SIGNAL(readyRead()), SLOT(recursiveReadyReadSlot()));
+ tmpSocket = smtp;
+
+ QSignalSpy spy(smtp, SIGNAL(readyRead()));
+
+ smtp->connectToHost("smtp.trolltech.com", 25);
+ enterLoop(30);
+ QVERIFY2(!timeout(),
+ "Timed out when connecting to smtp.trolltech.com:25");
+
+ enterLoop(30);
+ QVERIFY2(!timeout(),
+ "Timed out when waiting for the readyRead() signal");
+
+ QCOMPARE(spy.count(), 1);
+
+ delete smtp;
+}
+
+void tst_QTcpSocket::recursiveReadyReadSlot()
+{
+ // make sure the server spits out more data
+ tmpSocket->write("NOOP\r\n");
+ tmpSocket->flush();
+
+ // indiscriminately enter the event loop and start processing
+ // events again. but oops! future socket notifications will cause
+ // undesired recursive behavior. Unless QTcpSocket is smart, which
+ // it of course is. :-)
+ QEventLoop loop;
+ for (int i = 0; i < 100; ++i)
+ loop.processEvents();
+
+ // all we really wanted to do was process some events, then exit
+ // the loop
+ exitLoop();
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::atEnd()
+{
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost(QtNetworkSettings::serverName(), 21);
+
+ QVERIFY(socket->waitForReadyRead(15000));
+ QTextStream stream(socket);
+ QVERIFY(!stream.atEnd());
+ QString greeting = stream.readLine();
+ QVERIFY(stream.atEnd());
+// QCOMPARE(greeting, QString("220 (vsFTPd 2.0.4)"));
+ QCOMPARE(greeting, QString("220 (vsFTPd 2.0.5)"));
+
+ delete socket;
+}
+
+class TestThread : public QThread
+{
+ Q_OBJECT
+
+public:
+ inline QByteArray data() const
+ {
+ return socketData;
+ }
+
+protected:
+ inline void run()
+ {
+#ifndef QT_NO_OPENSSL
+ QFETCH_GLOBAL(bool, ssl);
+ if (ssl)
+ socket = new QSslSocket;
+ else
+#endif
+ socket = new QTcpSocket;
+ connect(socket, SIGNAL(readyRead()), this, SLOT(getData()), Qt::DirectConnection);
+ connect(socket, SIGNAL(disconnected()), this, SLOT(closed()), Qt::DirectConnection);
+ connect(socket, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
+ SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)), Qt::DirectConnection);
+
+ socket->connectToHost(QtNetworkSettings::serverName(), 21);
+ socket->write("QUIT\r\n");
+ exec();
+
+ delete socket;
+ }
+
+private slots:
+ inline void getData()
+ {
+ socketData += socket->readAll();
+ }
+
+ inline void closed()
+ {
+ quit();
+ }
+ inline void proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *auth)
+ {
+ auth->setUser("qsockstest");
+ auth->setPassword("password");
+ }
+private:
+ int exitCode;
+ QTcpSocket *socket;
+ QByteArray socketData;
+};
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::socketInAThread()
+{
+ for (int i = 0; i < 3; ++i) {
+ TestThread thread;
+ thread.start();
+ QVERIFY(thread.wait(15000));
+ QCOMPARE(thread.data(),
+// QByteArray("220 (vsFTPd 2.0.4)\r\n221 Goodbye.\r\n"));
+ QByteArray("220 (vsFTPd 2.0.5)\r\n221 Goodbye.\r\n"));
+ }
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::socketsInThreads()
+{
+ for (int i = 0; i < 3; ++i) {
+ TestThread thread1;
+ TestThread thread2;
+ TestThread thread3;
+
+ thread1.start();
+ thread2.start();
+ thread3.start();
+
+ QVERIFY(thread2.wait(15000));
+ QVERIFY(thread3.wait(15000));
+ QVERIFY(thread1.wait(15000));
+
+ QCOMPARE(thread1.data(),
+ QByteArray("220 (vsFTPd 2.0.5)\r\n221 Goodbye.\r\n"));
+ QCOMPARE(thread2.data(),
+ QByteArray("220 (vsFTPd 2.0.5)\r\n221 Goodbye.\r\n"));
+ QCOMPARE(thread3.data(),
+ QByteArray("220 (vsFTPd 2.0.5)\r\n221 Goodbye.\r\n"));
+ }
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::waitForReadyReadInASlot()
+{
+ QTcpSocket *socket = newSocket();
+ tmpSocket = socket;
+ connect(socket, SIGNAL(connected()), this, SLOT(waitForReadyReadInASlotSlot()));
+
+ socket->connectToHost(QtNetworkSettings::serverName(), 80);
+ socket->write("GET / HTTP/1.0\r\n\r\n");
+
+ enterLoop(30);
+ QVERIFY(!timeout());
+
+ delete socket;
+}
+
+void tst_QTcpSocket::waitForReadyReadInASlotSlot()
+{
+ QVERIFY(tmpSocket->waitForReadyRead(10000));
+ exitLoop();
+}
+
+class RemoteCloseErrorServer : public QTcpServer
+{
+ Q_OBJECT
+public:
+ RemoteCloseErrorServer()
+ {
+ connect(this, SIGNAL(newConnection()),
+ this, SLOT(getConnection()));
+ }
+
+private slots:
+ void getConnection()
+ {
+ tst_QTcpSocket::exitLoop();
+ }
+};
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::remoteCloseError()
+{
+ RemoteCloseErrorServer server;
+ QVERIFY(server.listen(QHostAddress::LocalHost));
+
+ QCoreApplication::instance()->processEvents();
+
+ QTcpSocket *clientSocket = newSocket();
+ connect(clientSocket, SIGNAL(readyRead()), this, SLOT(exitLoopSlot()));
+
+ clientSocket->connectToHost(server.serverAddress(), server.serverPort());
+
+ enterLoop(30);
+ QVERIFY(!timeout());
+
+ QVERIFY(server.hasPendingConnections());
+ QTcpSocket *serverSocket = server.nextPendingConnection();
+ connect(clientSocket, SIGNAL(disconnected()), this, SLOT(exitLoopSlot()));
+
+ serverSocket->write("Hello");
+
+ enterLoop(30);
+ QVERIFY(!timeout());
+
+ QCOMPARE(clientSocket->bytesAvailable(), qint64(5));
+
+ qRegisterMetaType<QAbstractSocket::SocketError>("QAbstractSocket::SocketError");
+ QSignalSpy errorSpy(clientSocket, SIGNAL(error(QAbstractSocket::SocketError)));
+ QSignalSpy disconnectedSpy(clientSocket, SIGNAL(disconnected()));
+
+ clientSocket->write("World");
+ serverSocket->disconnectFromHost();
+
+ tmpSocket = clientSocket;
+ connect(clientSocket, SIGNAL(error(QAbstractSocket::SocketError)),
+ this, SLOT(remoteCloseErrorSlot()));
+
+ enterLoop(30);
+ QVERIFY(!timeout());
+
+ QCOMPARE(disconnectedSpy.count(), 1);
+ QCOMPARE(errorSpy.count(), 1);
+ QCOMPARE(clientSocket->error(), QAbstractSocket::RemoteHostClosedError);
+
+ delete serverSocket;
+
+ clientSocket->connectToHost(server.serverAddress(), server.serverPort());
+
+ enterLoop(30);
+ QVERIFY(!timeout());
+
+ QVERIFY(server.hasPendingConnections());
+ serverSocket = server.nextPendingConnection();
+ serverSocket->disconnectFromHost();
+
+ enterLoop(30);
+ QVERIFY(!timeout());
+
+ QCOMPARE(clientSocket->state(), QAbstractSocket::UnconnectedState);
+
+ delete clientSocket;
+}
+
+void tst_QTcpSocket::remoteCloseErrorSlot()
+{
+ QCOMPARE(tmpSocket->state(), QAbstractSocket::ConnectedState);
+ static_cast<QTcpSocket *>(sender())->close();
+}
+
+void tst_QTcpSocket::messageBoxSlot()
+{
+ QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
+ socket->deleteLater();
+ QMessageBox box;
+ QTimer::singleShot(100, &box, SLOT(close()));
+
+ // This should not delete the socket
+ box.exec();
+
+ // Fire a non-0 singleshot to leave time for the delete
+ QTimer::singleShot(250, this, SLOT(exitLoopSlot()));
+}
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::openMessageBoxInErrorSlot()
+{
+ QTcpSocket *socket = newSocket();
+ QPointer<QTcpSocket> p(socket);
+ connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(messageBoxSlot()));
+
+ socket->connectToHost("hostnotfoundhostnotfound.troll.no", 9999); // Host not found, fyi
+ enterLoop(30);
+ QVERIFY(!p);
+}
+
+//----------------------------------------------------------------------------------
+#ifndef Q_OS_WIN
+void tst_QTcpSocket::connectToLocalHostNoService()
+{
+ // This test was created after we received a report that claimed
+ // QTcpSocket would crash if trying to connect to "localhost" on a random
+ // port with no service listening.
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost("localhost", 31415); // no service running here, one suspects
+
+ while(socket->state() == QTcpSocket::HostLookupState || socket->state() == QTcpSocket::ConnectingState) {
+ QTest::qWait(100);
+ }
+ QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
+ delete socket;
+}
+#endif
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::waitForConnectedInHostLookupSlot()
+{
+ // This test tries to reproduce the problem where waitForConnected() is
+ // called at a point where the host lookup is already done. QTcpSocket
+ // will try to abort the "pending lookup", but since it's already done and
+ // the queued signal is already underway, we will receive the signal after
+ // waitForConnected() has returned, and control goes back to the event
+ // loop. When the signal has been received, the connection is torn down,
+ // then reopened. Yikes. If we reproduce this by calling
+ // waitForConnected() inside hostLookupSlot(), it will even crash.
+ tmpSocket = newSocket();
+ QEventLoop loop;
+ connect(tmpSocket, SIGNAL(connected()), &loop, SLOT(quit()));
+ QTimer timer;
+ connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));
+ QSignalSpy timerSpy(&timer, SIGNAL(timeout()));
+ timer.start(15000);
+
+ connect(tmpSocket, SIGNAL(hostFound()), this, SLOT(hostLookupSlot()));
+ tmpSocket->connectToHost(QtNetworkSettings::serverName(), 143);
+
+ loop.exec();
+ QCOMPARE(timerSpy.count(), 0);
+
+ delete tmpSocket;
+}
+
+void tst_QTcpSocket::hostLookupSlot()
+{
+ // This will fail to cancel the pending signal
+ QVERIFY(tmpSocket->waitForConnected(10000));
+}
+
+class Foo : public QObject
+{
+ Q_OBJECT
+ QTcpSocket *sock;
+public:
+ bool attemptedToConnect;
+ bool networkTimeout;
+ int count;
+
+ inline Foo(QObject *parent = 0) : QObject(parent)
+ {
+ attemptedToConnect = false;
+ networkTimeout = false;
+ count = 0;
+#ifndef QT_NO_OPENSSL
+ QFETCH_GLOBAL(bool, ssl);
+ if (ssl)
+ sock = new QSslSocket;
+ else
+#endif
+ sock = new QTcpSocket;
+ connect(sock, SIGNAL(connected()), this, SLOT(connectedToIt()));
+ connect(sock, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
+ SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));
+ }
+
+ inline ~Foo()
+ {
+ delete sock;
+ }
+
+public slots:
+ inline void connectedToIt()
+ { count++; }
+
+ inline void doIt()
+ {
+ attemptedToConnect = true;
+ sock->connectToHost(QtNetworkSettings::serverName(), 80);
+
+#ifdef Q_OS_MAC
+ pthread_yield_np();
+#elif defined Q_OS_LINUX
+ pthread_yield();
+#endif
+ if (!sock->waitForConnected()) {
+ networkTimeout = true;
+ }
+ tst_QTcpSocket::exitLoop();
+ }
+
+ inline void exitLoop()
+ {
+ tst_QTcpSocket::exitLoop();
+ }
+
+ inline void proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *auth)
+ {
+ auth->setUser("qsockstest");
+ auth->setPassword("password");
+ }
+};
+
+//----------------------------------------------------------------------------------
+#ifndef Q_OS_WIN
+void tst_QTcpSocket::waitForConnectedInHostLookupSlot2()
+{
+
+ Foo foo;
+ QPushButton top("Go", 0);
+ top.show();
+ connect(&top, SIGNAL(clicked()), &foo, SLOT(doIt()));
+
+ QTimer::singleShot(100, &top, SLOT(animateClick()));
+ QTimer::singleShot(5000, &foo, SLOT(exitLoop()));
+
+ enterLoop(30);
+ if (timeout() || foo.networkTimeout)
+ QFAIL("Network timeout");
+
+ QVERIFY(foo.attemptedToConnect);
+ QCOMPARE(foo.count, 1);
+}
+#endif
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::readyReadSignalsAfterWaitForReadyRead()
+{
+ QTcpSocket *socket = newSocket();
+
+ QSignalSpy readyReadSpy(socket, SIGNAL(readyRead()));
+
+ // Connect
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+
+ // Wait for the read
+ QVERIFY(socket->waitForReadyRead(10000));
+
+ QCOMPARE(readyReadSpy.count(), 1);
+
+ QString s = socket->readLine();
+ QCOMPARE(s.toLatin1().constData(), "* OK [CAPABILITY IMAP4 IMAP4rev1 LITERAL+ ID STARTTLS LOGINDISABLED] qt-test-server.qt-test-net Cyrus IMAP4 v2.3.11-Mandriva-RPM-2.3.11-6mdv2008.1 server ready\r\n");
+ QCOMPARE(socket->bytesAvailable(), qint64(0));
+
+ QCoreApplication::instance()->processEvents();
+ QCOMPARE(socket->bytesAvailable(), qint64(0));
+ QCOMPARE(readyReadSpy.count(), 1);
+
+ delete socket;
+}
+
+class TestThread2 : public QThread
+{
+ Q_OBJECT
+public:
+ void run()
+ {
+ QFile fileWriter("fifo");
+ QVERIFY(fileWriter.open(QFile::WriteOnly));
+ QCOMPARE(fileWriter.write(QByteArray(32, '@')), qint64(32));
+ QCOMPARE(fileWriter.write(QByteArray(32, '@')), qint64(32));
+ QCOMPARE(fileWriter.write(QByteArray(32, '@')), qint64(32));
+ QCOMPARE(fileWriter.write(QByteArray(32, '@')), qint64(32));
+ }
+};
+
+//----------------------------------------------------------------------------------
+#ifdef Q_OS_LINUX
+void tst_QTcpSocket::linuxKernelBugLocalSocket()
+{
+ QFile::remove("fifo");
+ mkfifo("fifo", 0666);
+
+ TestThread2 test;
+ test.start();
+
+ QFile fileReader("fifo");
+ QVERIFY(fileReader.open(QFile::ReadOnly));
+
+ test.wait();
+
+ QTcpSocket *socket = newSocket();
+ socket->setSocketDescriptor(fileReader.handle());
+ QVERIFY(socket->waitForReadyRead(5000));
+ QCOMPARE(socket->bytesAvailable(), qint64(128));
+
+ QFile::remove("fifo");
+
+ delete socket;
+}
+#endif
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::abortiveClose()
+{
+ QTcpServer server;
+ QVERIFY(server.listen(QHostAddress::LocalHost));
+ connect(&server, SIGNAL(newConnection()), this, SLOT(exitLoopSlot()));
+
+ QTcpSocket *clientSocket = newSocket();
+ clientSocket->connectToHost(server.serverAddress(), server.serverPort());
+
+ enterLoop(10);
+ QVERIFY(server.hasPendingConnections());
+
+ QVERIFY(tmpSocket = server.nextPendingConnection());
+
+ qRegisterMetaType<QAbstractSocket::SocketError>("QAbstractSocket::SocketError");
+ QSignalSpy readyReadSpy(clientSocket, SIGNAL(readyRead()));
+ QSignalSpy errorSpy(clientSocket, SIGNAL(error(QAbstractSocket::SocketError)));
+
+ connect(clientSocket, SIGNAL(disconnected()), this, SLOT(exitLoopSlot()));
+ QTimer::singleShot(0, this, SLOT(abortiveClose_abortSlot()));
+
+ enterLoop(5);
+
+ QCOMPARE(readyReadSpy.count(), 0);
+ QCOMPARE(errorSpy.count(), 1);
+
+ QCOMPARE(*static_cast<const int *>(errorSpy.at(0).at(0).constData()),
+ int(QAbstractSocket::RemoteHostClosedError));
+
+ delete clientSocket;
+}
+
+void tst_QTcpSocket::abortiveClose_abortSlot()
+{
+ tmpSocket->abort();
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::localAddressEmptyOnBSD()
+{
+ QTcpServer server;
+ QVERIFY(server.listen(QHostAddress::LocalHost));
+
+ QTcpSocket *tcpSocket = 0;
+ // we try 10 times, but note that this doesn't always provoke the bug
+ for (int i = 0; i < 10; ++i) {
+ delete tcpSocket;
+ tcpSocket = newSocket();
+ tcpSocket->connectToHost(QHostAddress::LocalHost, server.serverPort());
+ if (!tcpSocket->waitForConnected(0)) {
+ // to provoke the bug, we need a local socket that connects immediately
+ // --i;
+ tcpSocket->abort();
+ if (tcpSocket->state() != QTcpSocket::UnconnectedState)
+ QVERIFY(tcpSocket->waitForDisconnected(-1));
+ continue;
+ }
+ QCOMPARE(tcpSocket->localAddress(), QHostAddress(QHostAddress::LocalHost));
+ }
+ delete tcpSocket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::zeroAndMinusOneReturns()
+{
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost(QtNetworkSettings::serverName(), 80);
+ socket->write("GET / HTTP/1.0\r\nConnection: keep-alive\r\n\r\n");
+ QVERIFY(socket->waitForReadyRead(15000));
+
+ char c[16];
+ QVERIFY(socket->getChar(c));
+ QCOMPARE(socket->read(c, 16), qint64(16));
+ QVERIFY(socket->readLine(c, 16) > 0);
+ QVERIFY(!socket->readAll().isEmpty());
+
+ // the last operation emptied the read buffer
+ // all read operations from this point on should fail
+ // with return 0 because the socket is still open
+ QVERIFY(socket->readAll().isEmpty());
+ QCOMPARE(socket->read(c, 16), qint64(0));
+ QCOMPARE(socket->readLine(c, 16), qint64(0));
+ QVERIFY(!socket->getChar(c));
+
+ socket->write("GET / HTTP/1.0\r\n\r\n");
+ QVERIFY(socket->waitForDisconnected(15000));
+ QCOMPARE(socket->error(), QAbstractSocket::RemoteHostClosedError);
+
+ QCOMPARE(socket->write("BLUBBER"), qint64(-1));
+ QVERIFY(socket->getChar(c));
+ QCOMPARE(socket->read(c, 16), qint64(16));
+ QVERIFY(socket->readLine(c, 16) > 0);
+ QVERIFY(!socket->readAll().isEmpty());
+
+ // the last operation emptied the read buffer
+ // all read operations from this point on should fail
+ // with return -1 because the socket is not connected
+ QVERIFY(socket->readAll().isEmpty());
+ QCOMPARE(socket->read(c, 16), qint64(-1));
+ QCOMPARE(socket->readLine(c, 16), qint64(-1));
+ QVERIFY(!socket->getChar(c));
+ QVERIFY(!socket->putChar('a'));
+
+ socket->close();
+
+ // now the QIODevice is closed, which means getChar complains
+ QCOMPARE(socket->write("BLUBBER"), qint64(-1));
+ QCOMPARE(socket->read(c, 16), qint64(-1));
+ QCOMPARE(socket->readLine(c, 16), qint64(-1));
+ QTest::ignoreMessage(QtWarningMsg, "QIODevice::getChar: Closed device");
+ QVERIFY(!socket->getChar(c));
+ QVERIFY(!socket->putChar('a'));
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::connectionRefused()
+{
+ qRegisterMetaType<QAbstractSocket::SocketError>("QAbstractSocket::SocketError");
+ qRegisterMetaType<QAbstractSocket::SocketState>("QAbstractSocket::SocketState");
+
+ QTcpSocket *socket = newSocket();
+ QSignalSpy stateSpy(socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)));
+ QSignalSpy errorSpy(socket, SIGNAL(error(QAbstractSocket::SocketError)));
+ connect(socket, SIGNAL(error(QAbstractSocket::SocketError)),
+ &QTestEventLoop::instance(), SLOT(exitLoop()));
+
+ socket->connectToHost(QtNetworkSettings::serverName(), 144);
+
+ enterLoop(10);
+ disconnect(socket, SIGNAL(error(QAbstractSocket::SocketError)),
+ &QTestEventLoop::instance(), SLOT(exitLoop()));
+ QVERIFY2(!timeout(), "Network timeout");
+
+ QCOMPARE(socket->state(), QAbstractSocket::UnconnectedState);
+ QCOMPARE(socket->error(), QAbstractSocket::ConnectionRefusedError);
+
+ QCOMPARE(stateSpy.count(), 3);
+ QCOMPARE(qVariantValue<QAbstractSocket::SocketState>(stateSpy.at(0).at(0)), QAbstractSocket::HostLookupState);
+ QCOMPARE(qVariantValue<QAbstractSocket::SocketState>(stateSpy.at(1).at(0)), QAbstractSocket::ConnectingState);
+ QCOMPARE(qVariantValue<QAbstractSocket::SocketState>(stateSpy.at(2).at(0)), QAbstractSocket::UnconnectedState);
+ QCOMPARE(errorSpy.count(), 1);
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::suddenRemoteDisconnect_data()
+{
+ QTest::addColumn<QString>("client");
+ QTest::addColumn<QString>("server");
+
+#ifdef QT3_SUPPORT
+ QTest::newRow("Qt3 Client <-> Qt3 Server") << QString::fromLatin1("qt3client") << QString::fromLatin1("qt3server");
+ QTest::newRow("Qt3 Client <-> Qt4 Server") << QString::fromLatin1("qt3client") << QString::fromLatin1("qt4server");
+ QTest::newRow("Qt4 Client <-> Qt3 Server") << QString::fromLatin1("qt4client") << QString::fromLatin1("qt3server");
+#endif
+
+ QTest::newRow("Qt4 Client <-> Qt4 Server") << QString::fromLatin1("qt4client") << QString::fromLatin1("qt4server");
+}
+
+void tst_QTcpSocket::suddenRemoteDisconnect()
+{
+#if defined(Q_OS_WINCE)
+ QSKIP("stressTest subprocess needs Qt3Support", SkipAll);
+#else
+ QFETCH(QString, client);
+ QFETCH(QString, server);
+
+ QFETCH_GLOBAL(bool, setProxy);
+ if (setProxy)
+ return;
+ QFETCH_GLOBAL(bool, ssl);
+ if (ssl)
+ return;
+
+ // Start server
+ QProcess serverProcess;
+ serverProcess.setReadChannel(QProcess::StandardError);
+ serverProcess.start(QString::fromLatin1("stressTest/stressTest %1").arg(server),
+ QIODevice::ReadWrite | QIODevice::Text);
+ while (!serverProcess.canReadLine())
+ QVERIFY(serverProcess.waitForReadyRead(10000));
+ QCOMPARE(serverProcess.readLine().data(), (server.toLatin1() + "\n").data());
+
+ // Start client
+ QProcess clientProcess;
+ clientProcess.setReadChannel(QProcess::StandardError);
+ clientProcess.start(QString::fromLatin1("stressTest/stressTest %1").arg(client),
+ QIODevice::ReadWrite | QIODevice::Text);
+ while (!clientProcess.canReadLine())
+ QVERIFY(clientProcess.waitForReadyRead(10000));
+ QCOMPARE(clientProcess.readLine().data(), (client.toLatin1() + "\n").data());
+
+ // Let them play for a while
+ qDebug("Running stress test for 5 seconds");
+ QEventLoop loop;
+ connect(&serverProcess, SIGNAL(finished(int)), &loop, SLOT(quit()));
+ connect(&clientProcess, SIGNAL(finished(int)), &loop, SLOT(quit()));
+ QTime stopWatch;
+ stopWatch.start();
+ QTimer::singleShot(20000, &loop, SLOT(quit()));
+
+ while ((serverProcess.state() == QProcess::Running
+ || clientProcess.state() == QProcess::Running) && stopWatch.elapsed() < 20000)
+ loop.exec();
+
+ QVERIFY(stopWatch.elapsed() < 20000);
+
+ // Check that both exited normally.
+ QCOMPARE(clientProcess.readAll().constData(), "SUCCESS\n");
+ QCOMPARE(serverProcess.readAll().constData(), "SUCCESS\n");
+#endif
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::connectToMultiIP()
+{
+ QSKIP("TODO: setup DNS in the new network", SkipAll);
+
+ QFETCH_GLOBAL(bool, ssl);
+ if (ssl)
+ return;
+ QFETCH_GLOBAL(bool, setProxy);
+ if (setProxy)
+ QSKIP("This test takes too long if we also add the proxies.", SkipSingle);
+
+ qDebug("Please wait, this test can take a while...");
+
+ QTcpSocket *socket = newSocket();
+ // rationale: this domain resolves to 3 A-records, 2 of them are
+ // invalid. QTcpSocket should never spend more than 30 seconds per IP, and
+ // 30s*2 = 60s.
+ QTime stopWatch;
+ stopWatch.start();
+ socket->connectToHost("multi.dev.troll.no", 80);
+ QVERIFY(socket->waitForConnected(60500));
+ QVERIFY(stopWatch.elapsed() < 70000);
+ socket->abort();
+
+ stopWatch.restart();
+ socket->connectToHost("multi.dev.troll.no", 81);
+ QVERIFY(!socket->waitForConnected(1000));
+ QVERIFY(stopWatch.elapsed() < 2000);
+ QCOMPARE(socket->error(), QAbstractSocket::SocketTimeoutError);
+
+ delete socket;
+}
+
+//----------------------------------------------------------------------------------
+void tst_QTcpSocket::moveToThread0()
+{
+ QFETCH_GLOBAL(int, proxyType);
+ if (proxyType & AuthMask)
+ return;
+
+ {
+ // Case 1: Moved after connecting, before waiting for connection.
+ QTcpSocket *socket = newSocket();;
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ socket->moveToThread(0);
+ QVERIFY(socket->waitForConnected(1000));
+ socket->write("XXX LOGOUT\r\n");
+ QVERIFY(socket->waitForBytesWritten(5000));
+ QVERIFY(socket->waitForDisconnected());
+ delete socket;
+ }
+ {
+ // Case 2: Moved before connecting
+ QTcpSocket *socket = newSocket();
+ socket->moveToThread(0);
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ QVERIFY(socket->waitForConnected(1000));
+ socket->write("XXX LOGOUT\r\n");
+ QVERIFY(socket->waitForBytesWritten(5000));
+ QVERIFY(socket->waitForDisconnected());
+ delete socket;
+ }
+ {
+ // Case 3: Moved after writing, while waiting for bytes to be written.
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ QVERIFY(socket->waitForConnected(1000));
+ socket->write("XXX LOGOUT\r\n");
+ socket->moveToThread(0);
+ QVERIFY(socket->waitForBytesWritten(5000));
+ QVERIFY(socket->waitForDisconnected());
+ delete socket;
+ }
+ {
+ // Case 4: Moved after writing, while waiting for response.
+ QTcpSocket *socket = newSocket();
+ socket->connectToHost(QtNetworkSettings::serverName(), 143);
+ QVERIFY(socket->waitForConnected(1000));
+ socket->write("XXX LOGOUT\r\n");
+ QVERIFY(socket->waitForBytesWritten(5000));
+ socket->moveToThread(0);
+ QVERIFY(socket->waitForDisconnected());
+ delete socket;
+ }
+}
+
+void tst_QTcpSocket::increaseReadBufferSize()
+{
+ QTcpServer server;
+ QTcpSocket *active = newSocket();
+ connect(active, SIGNAL(readyRead()), SLOT(exitLoopSlot()));
+
+ // connect two sockets to each other:
+ QVERIFY(server.listen(QHostAddress::LocalHost));
+ active->connectToHost("127.0.0.1", server.serverPort());
+ QVERIFY(active->waitForConnected(5000));
+ QVERIFY(server.waitForNewConnection(5000));
+
+ QTcpSocket *passive = server.nextPendingConnection();
+ QVERIFY(passive);
+
+ // now write 512 bytes of data on one end
+ QByteArray data(512, 'a');
+ passive->write(data);
+ QVERIFY2(passive->waitForBytesWritten(5000), "Network timeout");
+
+ // set the read buffer size to less than what was written and iterate:
+ active->setReadBufferSize(256);
+ enterLoop(10);
+ QVERIFY2(!timeout(), "Network timeout");
+ QCOMPARE(active->bytesAvailable(), active->readBufferSize());
+
+ // increase the buffer size and iterate again:
+ active->setReadBufferSize(384);
+ enterLoop(10);
+ QVERIFY2(!timeout(), "Network timeout");
+ QCOMPARE(active->bytesAvailable(), active->readBufferSize());
+
+ // once more, but now it should read everything there was to read
+ active->setReadBufferSize(1024);
+ enterLoop(10);
+ QVERIFY2(!timeout(), "Network timeout");
+ QCOMPARE(active->bytesAvailable(), qint64(data.size()));
+
+ // drain it and compare
+ QCOMPARE(active->readAll(), data);
+
+ // now one more test by setting the buffer size to unlimited:
+ passive->write(data);
+ QVERIFY2(passive->waitForBytesWritten(5000), "Network timeout");
+ active->setReadBufferSize(256);
+ enterLoop(10);
+ QVERIFY2(!timeout(), "Network timeout");
+ QCOMPARE(active->bytesAvailable(), active->readBufferSize());
+ active->setReadBufferSize(0);
+ enterLoop(10);
+ QVERIFY2(!timeout(), "Network timeout");
+ QCOMPARE(active->bytesAvailable(), qint64(data.size()));
+ QCOMPARE(active->readAll(), data);
+
+ delete active;
+}
+
+#ifdef TEST_QNETWORK_PROXY
+void tst_QTcpSocket::invalidProxy_data()
+{
+ QTest::addColumn<int>("type");
+ QTest::addColumn<QString>("host");
+ QTest::addColumn<int>("port");
+ QTest::addColumn<bool>("failsAtConnect");
+ QTest::addColumn<int>("expectedError");
+
+ QString fluke = QHostInfo::fromName(QtNetworkSettings::serverName()).addresses().first().toString();
+ QTest::newRow("ftp-proxy") << int(QNetworkProxy::FtpCachingProxy) << fluke << 21 << true
+ << int(QAbstractSocket::UnsupportedSocketOperationError);
+ QTest::newRow("http-caching-proxy") << int(QNetworkProxy::HttpCachingProxy) << fluke << 3128 << true
+ << int(QAbstractSocket::UnsupportedSocketOperationError);
+ QTest::newRow("no-such-host-socks5") << int(QNetworkProxy::Socks5Proxy)
+ << "this-host-will-never-exist.troll.no" << 1080 << false
+ << int(QAbstractSocket::ProxyNotFoundError);
+ QTest::newRow("no-such-host-http") << int(QNetworkProxy::HttpProxy)
+ << "this-host-will-never-exist.troll.no" << 3128 << false
+ << int(QAbstractSocket::ProxyNotFoundError);
+
+ QTest::newRow("http-on-socks5") << int(QNetworkProxy::HttpProxy) << fluke << 1080 << false
+ << int(QAbstractSocket::ProxyConnectionClosedError);
+ QTest::newRow("socks5-on-http") << int(QNetworkProxy::Socks5Proxy) << fluke << 3128 << false
+ << int(QAbstractSocket::SocketTimeoutError);
+}
+
+void tst_QTcpSocket::invalidProxy()
+{
+ QFETCH_GLOBAL(bool, setProxy);
+ if (setProxy)
+ return;
+
+ QFETCH(int, type);
+ QFETCH(QString, host);
+ QFETCH(int, port);
+ QFETCH(bool, failsAtConnect);
+ QNetworkProxy::ProxyType proxyType = QNetworkProxy::ProxyType(type);
+ QNetworkProxy proxy(proxyType, host, port);
+
+ QTcpSocket *socket = newSocket();
+ socket->setProxy(proxy);
+ socket->connectToHost(QHostInfo::fromName(QtNetworkSettings::serverName()).addresses().first().toString(), 80);
+
+ if (failsAtConnect) {
+ QCOMPARE(socket->state(), QAbstractSocket::UnconnectedState);
+ } else {
+ QCOMPARE(socket->state(), QAbstractSocket::ConnectingState);
+ QVERIFY(!socket->waitForConnected(1000));
+ }
+ QVERIFY(!socket->errorString().isEmpty());
+
+ // note: the following test is not a hard failure.
+ // Sometimes, error codes change for the better
+ QTEST(int(socket->error()), "expectedError");
+
+ delete socket;
+}
+
+// copied from tst_qnetworkreply.cpp
+class MyProxyFactory: public QNetworkProxyFactory
+{
+public:
+ int callCount;
+ QList<QNetworkProxy> toReturn;
+ QNetworkProxyQuery lastQuery;
+ inline MyProxyFactory() { clear(); }
+
+ inline void clear()
+ {
+ callCount = 0;
+ toReturn = QList<QNetworkProxy>() << QNetworkProxy::DefaultProxy;
+ lastQuery = QNetworkProxyQuery();
+ }
+
+ virtual QList<QNetworkProxy> queryProxy(const QNetworkProxyQuery &query)
+ {
+ lastQuery = query;
+ ++callCount;
+ return toReturn;
+ }
+};
+
+void tst_QTcpSocket::proxyFactory_data()
+{
+ QTest::addColumn<QList<QNetworkProxy> >("proxyList");
+ QTest::addColumn<QNetworkProxy>("proxyUsed");
+ QTest::addColumn<bool>("failsAtConnect");
+ QTest::addColumn<int>("expectedError");
+
+ QList<QNetworkProxy> proxyList;
+
+ // tests that do connect
+
+ proxyList << QNetworkProxy(QNetworkProxy::HttpProxy, QtNetworkSettings::serverName(), 3129);
+ QTest::newRow("http")
+ << proxyList << proxyList.at(0)
+ << false << int(QAbstractSocket::UnknownSocketError);
+
+ proxyList.clear();
+ proxyList << QNetworkProxy(QNetworkProxy::Socks5Proxy, QtNetworkSettings::serverName(), 1081);
+ QTest::newRow("socks5")
+ << proxyList << proxyList.at(0)
+ << false << int(QAbstractSocket::UnknownSocketError);
+
+ proxyList.clear();
+ proxyList << QNetworkProxy(QNetworkProxy::HttpCachingProxy, QtNetworkSettings::serverName(), 3129)
+ << QNetworkProxy(QNetworkProxy::Socks5Proxy, QtNetworkSettings::serverName(), 1081);
+ QTest::newRow("cachinghttp+socks5")
+ << proxyList << proxyList.at(1)
+ << false << int(QAbstractSocket::UnknownSocketError);
+
+ proxyList.clear();
+ proxyList << QNetworkProxy(QNetworkProxy::FtpCachingProxy, QtNetworkSettings::serverName(), 2121)
+ << QNetworkProxy(QNetworkProxy::HttpCachingProxy, QtNetworkSettings::serverName(), 3129)
+ << QNetworkProxy(QNetworkProxy::Socks5Proxy, QtNetworkSettings::serverName(), 1081);
+ QTest::newRow("ftp+cachinghttp+socks5")
+ << proxyList << proxyList.at(2)
+ << false << int(QAbstractSocket::UnknownSocketError);
+
+ // tests that fail to connect
+ proxyList.clear();
+ proxyList << QNetworkProxy(QNetworkProxy::HttpCachingProxy, QtNetworkSettings::serverName(), 3129);
+ QTest::newRow("cachinghttp")
+ << proxyList << QNetworkProxy()
+ << true << int(QAbstractSocket::UnsupportedSocketOperationError);
+
+ proxyList.clear();
+ proxyList << QNetworkProxy(QNetworkProxy::FtpCachingProxy, QtNetworkSettings::serverName(), 2121);
+ QTest::newRow("ftp")
+ << proxyList << QNetworkProxy()
+ << true << int(QAbstractSocket::UnsupportedSocketOperationError);
+
+ proxyList.clear();
+ proxyList << QNetworkProxy(QNetworkProxy::FtpCachingProxy, QtNetworkSettings::serverName(), 2121)
+ << QNetworkProxy(QNetworkProxy::HttpCachingProxy, QtNetworkSettings::serverName(), 3129);
+ QTest::newRow("ftp+cachinghttp")
+ << proxyList << QNetworkProxy()
+ << true << int(QAbstractSocket::UnsupportedSocketOperationError);
+}
+
+void tst_QTcpSocket::proxyFactory()
+{
+ QFETCH_GLOBAL(bool, setProxy);
+ if (setProxy)
+ return;
+
+ QFETCH(QList<QNetworkProxy>, proxyList);
+ QFETCH(QNetworkProxy, proxyUsed);
+ QFETCH(bool, failsAtConnect);
+
+ MyProxyFactory *factory = new MyProxyFactory;
+ factory->toReturn = proxyList;
+ QNetworkProxyFactory::setApplicationProxyFactory(factory);
+
+ QTcpSocket *socket = newSocket();
+ QString host = QtNetworkSettings::serverName();
+ socket->connectToHost(host, 80);
+
+ // Verify that the factory was called properly
+ QCOMPARE(factory->callCount, 1);
+ QCOMPARE(factory->lastQuery, QNetworkProxyQuery(host, 80));
+
+ if (failsAtConnect) {
+ QCOMPARE(socket->state(), QAbstractSocket::UnconnectedState);
+ } else {
+ QCOMPARE(socket->state(), QAbstractSocket::ConnectingState);
+ QVERIFY(socket->waitForConnected(10000));
+ QCOMPARE(proxyAuthCalled, 1);
+ }
+ QVERIFY(!socket->errorString().isEmpty());
+
+ // note: the following test is not a hard failure.
+ // Sometimes, error codes change for the better
+ QTEST(int(socket->error()), "expectedError");
+
+ delete socket;
+}
+#endif
+
+QTEST_MAIN(tst_QTcpSocket)
+#include "tst_qtcpsocket.moc"
generated by cgit v0.12 at 2024-11-14 13:08:33 (GMT)