diff options
Diffstat (limited to 'tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp')
| -rw-r--r-- | tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp | 2684 |
1 files changed, 2684 insertions, 0 deletions
diff --git a/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp b/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp new file mode 100644 index 0000000000..bae3f7c2f5 --- /dev/null +++ b/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp @@ -0,0 +1,2684 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the test suite of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** GNU Lesser General Public License Usage +** 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. +** +** 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. +** +** Other Usage +** Alternatively, this file may be used in accordance with the terms and +** conditions contained in a signed written agreement between you and Nokia. +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + + +// Just to get Q_OS_SYMBIAN +#include <qglobal.h> + +#if defined(_WIN32) && !defined(Q_OS_SYMBIAN) +#include <winsock2.h> +#else +#include <sys/types.h> +#include <sys/socket.h> +#include <fcntl.h> +#include <unistd.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> +#ifndef Q_OS_VXWORKS +#include <QMessageBox> +#include <QPushButton> +#endif +#include <QPointer> +#include <QProcess> +#include <QStringList> +#include <QTcpServer> +#include <QTcpSocket> +#ifndef QT_NO_OPENSSL +#include <QSslSocket> +#endif +#include <QTextStream> +#include <QThread> +#include <QTime> +#include <QTimer> +#include <QDebug> +// RVCT compiles also unused inline methods +# include <QNetworkProxy> + +#ifdef Q_OS_LINUX +#include <stdio.h> +#include <stdlib.h> +#include <sys/stat.h> +#include <unistd.h> +#endif + +#include "private/qhostinfo_p.h" + +#include "../../../network-settings.h" +#include "../../../../shared/util.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) +QT_FORWARD_DECLARE_CLASS(SocketPair) + +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 socketsConstructedBeforeEventLoop(); + void constructing(); + void setInvalidSocketDescriptor(); + void setSocketDescriptor(); + void socketDescriptor(); + void blockingIMAP(); + void nonBlockingIMAP(); + void hostNotFound(); + void timeoutConnect_data(); + 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 waitForBytesWrittenMinusOne(); + void waitForReadyRead(); + void waitForReadyReadMinusOne(); + 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(); + void waitForConnectedInHostLookupSlot2(); + 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(); + void taskQtBug5799ConnectionErrorWaitForConnected(); + void taskQtBug5799ConnectionErrorEventLoop(); + void taskQtBug7054TimeoutErrorResetting(); + + void invalidProxy_data(); + void invalidProxy(); + void proxyFactory_data(); + void proxyFactory(); + + void qtbug14268_peek(); + + +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); + void earlySocketBytesSent(qint64 bytes); + void earlySocketReadyRead(); + +private: + QByteArray expectedReplyIMAP(); + void fetchExpectedReplyIMAP(); + QTcpSocket *newSocket() const; + QTcpSocket *nonBlockingIMAP_socket; + QStringList nonBlockingIMAP_data; + qint64 nonBlockingIMAP_totalWritten; + + QTcpSocket *tmpSocket; + qint64 bytesAvailable; + qint64 expectedLength; + bool readingBody; + QTime timer; + + QByteArray expectedReplyIMAP_cached; + + mutable int proxyAuthCalled; + + bool gotClosedSignal; + int numConnections; + static int loopLevel; + + SocketPair *earlyConstructedSockets; + int earlyBytesWrittenCount; + int earlyReadyReadCount; +}; + +enum ProxyTests { + NoProxy = 0x00, + Socks5Proxy = 0x01, + HttpProxy = 0x02, + TypeMask = 0x0f, + + NoAuth = 0x00, + AuthBasic = 0x10, + AuthNtlm = 0x20, + AuthMask = 0xf0 +}; + +int tst_QTcpSocket::loopLevel = 0; + +class SocketPair: public QObject +{ + Q_OBJECT +public: + QTcpSocket *endPoints[2]; + + SocketPair(QObject *parent = 0) + : QObject(parent) + { + endPoints[0] = endPoints[1] = 0; + } + + bool create() + { + QTcpServer server; + server.listen(); + + QTcpSocket *active = new QTcpSocket(this); + active->connectToHost("127.0.0.1", server.serverPort()); + + if (!active->waitForConnected(1000)) + return false; + + if (!server.waitForNewConnection(1000)) + return false; + + QTcpSocket *passive = server.nextPendingConnection(); + passive->setParent(this); + + endPoints[0] = active; + endPoints[1] = passive; + return true; + } +}; + +tst_QTcpSocket::tst_QTcpSocket() +{ + tmpSocket = 0; + + //This code relates to the socketsConstructedBeforeEventLoop test case + earlyConstructedSockets = new SocketPair; + QVERIFY(earlyConstructedSockets->create()); + earlyBytesWrittenCount = 0; + earlyReadyReadCount = 0; + connect(earlyConstructedSockets->endPoints[0], SIGNAL(readyRead()), this, SLOT(earlySocketReadyRead())); + connect(earlyConstructedSockets->endPoints[1], SIGNAL(bytesWritten(qint64)), this, SLOT(earlySocketBytesSent(qint64))); + earlyConstructedSockets->endPoints[1]->write("hello work"); +} + +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; + 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; + +#ifndef QT_NO_OPENSSL + QTest::newRow("WithoutProxy SSL") << false << 0 << true; + 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 +} + +void tst_QTcpSocket::init() +{ + QFETCH_GLOBAL(bool, setProxy); + if (setProxy) { + QFETCH_GLOBAL(int, proxyType); + QList<QHostAddress> addresses = QHostInfo::fromName(QtNetworkSettings::serverName()).addresses(); + QVERIFY2(addresses.count() > 0, "failed to get ip address for test server"); + QString fluke = 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); + } + + qt_qhostinfo_clear_cache(); +} + +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() +{ + QNetworkProxy::setApplicationProxy(QNetworkProxy::DefaultProxy); +} + +void tst_QTcpSocket::proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *auth) +{ + ++proxyAuthCalled; + auth->setUser("qsockstest"); + auth->setPassword("password"); +} + +//---------------------------------------------------------------------------------- + +void tst_QTcpSocket::socketsConstructedBeforeEventLoop() +{ + QFETCH_GLOBAL(bool, setProxy); + QFETCH_GLOBAL(bool, ssl); + if (setProxy || ssl) + return; + //This test checks that sockets constructed before QCoreApplication::exec() still emit signals + //see construction code in the tst_QTcpSocket constructor + enterLoop(3); + QCOMPARE(earlyBytesWrittenCount, 1); + QCOMPARE(earlyReadyReadCount, 1); + earlyConstructedSockets->endPoints[0]->close(); + earlyConstructedSockets->endPoints[1]->close(); +} + +void tst_QTcpSocket::earlySocketBytesSent(qint64 /* bytes */) +{ + earlyBytesWrittenCount++; +} + +void tst_QTcpSocket::earlySocketReadyRead() +{ + earlyReadyReadCount++; +} + +//---------------------------------------------------------------------------------- + +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; + 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); +#ifdef Q_OS_SYMBIAN + QTest::ignoreMessage(QtWarningMsg, "QSymbianSocketEngine::initialize - socket descriptor not found"); +#endif + QVERIFY(!socket->setSocketDescriptor(-5, QTcpSocket::UnconnectedState)); + QCOMPARE(socket->socketDescriptor(), -1); + + QCOMPARE(socket->error(), QTcpSocket::UnsupportedSocketOperationError); + + delete socket; +} + +//---------------------------------------------------------------------------------- + +void tst_QTcpSocket::setSocketDescriptor() +{ +#ifdef Q_OS_SYMBIAN + QSKIP("adopting open c socket handles is not supported", SkipAll); +#else + 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); + + // artificially increase the value of sock + SOCKET sock2 = ::fcntl(sock, F_DUPFD, sock + 50); + ::close(sock); + sock = sock2; +#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)); + // skip this, it has been broken for years, see task 260735 + // if somebody complains, consider fixing it, but it might break existing applications. + QEXPECT_FAIL("", "bug has been around for years, will not fix without need", Continue); + QCOMPARE(socket->socketDescriptor(), (int)sock); + delete socket; +#ifdef Q_OS_WIN + delete dummy; +#endif +#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_data() +{ + QTest::addColumn<QString>("address"); + QTest::newRow("host") << QtNetworkSettings::serverName(); + QTest::newRow("ip") << QtNetworkSettings::serverIP().toString(); +} + +void tst_QTcpSocket::timeoutConnect() +{ + QFETCH(QString, address); + QTcpSocket *socket = newSocket(); + + QElapsedTimer timer; + timer.start(); + + // Port 1357 is configured to drop packets on the test server + socket->connectToHost(address, 1357); + QVERIFY(timer.elapsed() < 150); + QVERIFY(!socket->waitForConnected(1000)); //200ms is too short when using SOCKS proxy authentication + QCOMPARE(socket->state(), QTcpSocket::UnconnectedState); + QCOMPARE(int(socket->error()), int(QTcpSocket::SocketTimeoutError)); + + timer.start(); + socket->connectToHost(address, 1357); + QVERIFY(timer.elapsed() < 150); + QTimer::singleShot(50, &QTestEventLoop::instance(), SLOT(exitLoop())); + QTestEventLoop::instance().enterLoop(5); + QVERIFY(!QTestEventLoop::instance().timeout()); + QVERIFY(socket->state() == QTcpSocket::ConnectingState + || socket->state() == QTcpSocket::HostLookupState); + 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).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; +} + + +//---------------------------------------------------------------------------------- + +QByteArray tst_QTcpSocket::expectedReplyIMAP() +{ + if (expectedReplyIMAP_cached.isEmpty()) { + fetchExpectedReplyIMAP(); + } + + return expectedReplyIMAP_cached; +} + +// Figure out how the current IMAP server responds +void tst_QTcpSocket::fetchExpectedReplyIMAP() +{ + QTcpSocket *socket = newSocket(); + socket->connectToHost(QtNetworkSettings::serverName(), 143); + QVERIFY2(socket->waitForConnected(10000), qPrintable(socket->errorString())); + QVERIFY2(socket->state() == QTcpSocket::ConnectedState, qPrintable(socket->errorString())); + + QTRY_VERIFY(socket->canReadLine()); + + QByteArray greeting = socket->readLine(); + delete socket; + + QVERIFY2(QtNetworkSettings::compareReplyIMAP(greeting), greeting.constData()); + + expectedReplyIMAP_cached = greeting; +} + +//---------------------------------------------------------------------------------- + +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 = expectedReplyIMAP(); + QVERIFY(!greeting.isEmpty()); + + 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 = expectedReplyIMAP(); + QVERIFY(!greeting.isEmpty()); + + for (int i = 0; i < 10; i += 2) { + while (socket->bytesAvailable() < 2) + QVERIFY(socket->waitForReadyRead(10000)); + 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; + 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); + QFETCH_GLOBAL(bool, setProxy); + if (setProxy) + return; //proxy not useful for localhost test case + + 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())); +#ifndef Q_OS_SYMBIAN + enterLoop(10); +#else + enterLoop(30); +#endif + 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() { } + + bool listen() + { + server = new QTcpServer; + if (!server->listen(QHostAddress::LocalHost)) + return false; + serverPort = server->serverPort(); + server->moveToThread(this); + return true; + } + + static void cleanup(void *ptr) + { + ReceiverThread* self = reinterpret_cast<ReceiverThread*>(ptr); + self->quit = true; + self->wait(30000); + delete self; + } + +protected: + void run() + { + bool timedOut = false; + while (!quit) { +#ifndef Q_OS_SYMBIAN + if (server->waitForNewConnection(500, &timedOut)) +#else + if (server->waitForNewConnection(5000, &timedOut)) +#endif + break; + if (!timedOut) + return; + } + + QTcpSocket *socket = server->nextPendingConnection(); + while (!quit) { +#ifndef Q_OS_SYMBIAN + if (socket->waitForDisconnected(500)) +#else + if (socket->waitForDisconnected(5000)) +#endif + 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); + QFETCH_GLOBAL(bool, setProxy); + if (setProxy) + return; //proxy not useful for localhost test case + + QScopedPointer<ReceiverThread, ReceiverThread> thread (new ReceiverThread); + 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) { + 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(); + } + +#ifndef Q_OS_SYMBIAN + QVERIFY2(socket->waitForDisconnected(10000), "Network timeout"); +#else + QVERIFY2(socket->waitForDisconnected(30000), "Network timeout"); +#endif + 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(30000)); + 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); + + // check that connect is in progress + QVERIFY(socket->state() != QAbstractSocket::UnconnectedState); + + 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; +#ifndef Q_OS_SYMBIAN + QTimer::singleShot(50, &loop, SLOT(quit())); +#else + QTimer::singleShot(5000, &loop, SLOT(quit())); +#endif + 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())); + connect(tmpSocket, SIGNAL(disconnected()), SLOT(exitLoopSlot())); + + 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 /qtest/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]; + + qint64 linelen = socket->readLine(buffer, sizeof(buffer)); + QVERIFY(linelen >= 3); + QVERIFY(linelen < 1024); + + QByteArray reply = QByteArray::fromRawData(buffer, linelen); + QCOMPARE((int) buffer[linelen-2], (int) '\r'); + QCOMPARE((int) buffer[linelen-1], (int) '\n'); + QCOMPARE((int) buffer[linelen], (int) '\0'); + + QVERIFY2(QtNetworkSettings::compareReplyIMAP(reply), reply.constData()); + + 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(); + socket->connectToHost(QtNetworkSettings::serverName(), 143); + QVERIFY(socket->waitForReadyRead(10000)); + + QByteArray arr = socket->readLine(); + QVERIFY2(QtNetworkSettings::compareReplyIMAP(arr), arr.constData()); + + 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(), 80); + QVERIFY(socket->waitForConnected(10000)); + + socket->write("GET / HTTP/1.0\r\n\r\n"); + qint64 toWrite = socket->bytesToWrite(); + QVERIFY(socket->waitForBytesWritten(5000)); + QVERIFY(toWrite > socket->bytesToWrite()); + + delete socket; +} + +//---------------------------------------------------------------------------------- +void tst_QTcpSocket::waitForBytesWrittenMinusOne() +{ + QTcpSocket *socket = newSocket(); + socket->connectToHost(QtNetworkSettings::serverName(), 80); + QVERIFY(socket->waitForConnected(10000)); + + socket->write("GET / HTTP/1.0\r\n\r\n"); + qint64 toWrite = socket->bytesToWrite(); + QVERIFY(socket->waitForBytesWritten(-1)); + QVERIFY(toWrite > socket->bytesToWrite()); + + delete socket; +} + +//---------------------------------------------------------------------------------- +void tst_QTcpSocket::waitForReadyRead() +{ + QTcpSocket *socket = newSocket(); + socket->connectToHost(QtNetworkSettings::serverName(), 80); + socket->write("GET / HTTP/1.0\r\n\r\n"); + QVERIFY(socket->waitForReadyRead(5000)); + delete socket; +} + +//---------------------------------------------------------------------------------- +void tst_QTcpSocket::waitForReadyReadMinusOne() +{ + QTcpSocket *socket = newSocket(); + socket->connectToHost(QtNetworkSettings::serverName(), 80); + socket->write("GET / HTTP/1.0\r\n\r\n"); + QVERIFY(socket->waitForReadyRead(-1)); + delete socket; +} + +//---------------------------------------------------------------------------------- +void tst_QTcpSocket::flush() +{ + QTcpSocket *socket = newSocket(); + socket->flush(); + + connect(socket, SIGNAL(connected()), SLOT(exitLoopSlot())); + socket->connectToHost(QtNetworkSettings::serverName(), 143); + enterLoop(60); + 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; + server.setProxy(QNetworkProxy(QNetworkProxy::NoProxy)); + QVERIFY(server.listen()); + + QHostAddress serverAddress = QHostAddress::LocalHost; + if (!(server.serverAddress() == QHostAddress::AnyIPv4) && !(server.serverAddress() == QHostAddress::AnyIPv6)) + serverAddress = server.serverAddress(); + + QTcpSocket *socket = newSocket(); + socket->connectToHost(serverAddress, server.serverPort()); +#ifndef Q_OS_SYMBIAN + QVERIFY(!socket->waitForReadyRead(100)); +#else + QVERIFY(!socket->waitForReadyRead(5000)); +#endif + QCOMPARE(socket->error(), QTcpSocket::SocketTimeoutError); + QVERIFY(socket->isOpen()); + +#ifndef Q_OS_SYMBIAN + QVERIFY(!socket->waitForDisconnected(100)); +#else + QVERIFY(!socket->waitForDisconnected(5000)); +#endif + 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()); + + // Test server must use some vsFTPd 2.x.x version + QVERIFY2(greeting.length() == sizeof("220 (vsFTPd 2.x.x)")-1, qPrintable(greeting)); + QVERIFY2(greeting.startsWith("220 (vsFTPd 2."), qPrintable(greeting)); + QVERIFY2(greeting.endsWith(")"), qPrintable(greeting)); + + 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)); + QByteArray data = thread.data(); + QVERIFY2(QtNetworkSettings::compareReplyFtp(data), data.constData()); + } +} + +//---------------------------------------------------------------------------------- +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)); + + QByteArray data1 = thread1.data(); + QByteArray data2 = thread2.data(); + QByteArray data3 = thread3.data(); + + QVERIFY2(QtNetworkSettings::compareReplyFtp(data1), data1.constData()); + QVERIFY2(QtNetworkSettings::compareReplyFtp(data2), data2.constData()); + QVERIFY2(QtNetworkSettings::compareReplyFtp(data3), data3.constData()); + } +} + +//---------------------------------------------------------------------------------- +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() +{ + QFETCH_GLOBAL(bool, setProxy); + if (setProxy) + return; //proxy not useful for localhost test case + 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() +{ +#if !defined(Q_OS_VXWORKS) // no gui + 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())); +#endif +} +//---------------------------------------------------------------------------------- +void tst_QTcpSocket::openMessageBoxInErrorSlot() +{ +#if defined(Q_OS_VXWORKS) // no gui + QSKIP("no default gui available on VxWorks", SkipAll); +#else + 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); +#endif +} + +//---------------------------------------------------------------------------------- +#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); + + // only execute the loop if not already connected + if (tmpSocket->state() != QAbstractSocket::ConnectedState) + 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"); + } +}; + +//---------------------------------------------------------------------------------- +void tst_QTcpSocket::waitForConnectedInHostLookupSlot2() +{ +#if defined(Q_OS_WIN) || defined(Q_OS_VXWORKS) + QSKIP("waitForConnectedInHostLookupSlot2 is not run on Windows and VxWorks", SkipAll); +#else + + 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(); + QVERIFY2(QtNetworkSettings::compareReplyIMAP(s.toLatin1()), s.toLatin1().constData()); + 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() +{ + QFETCH_GLOBAL(bool, setProxy); + if (setProxy) + return; //proxy not useful for localhost test case + 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() +{ + QFETCH_GLOBAL(bool, setProxy); + if (setProxy) + return; //proxy not useful for localhost test case + 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)); + 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"); + + QTest::newRow("Qt4 Client <-> Qt4 Server") << QString::fromLatin1("qt4client") << QString::fromLatin1("qt4server"); +} + +void tst_QTcpSocket::suddenRemoteDisconnect() +{ +#if defined( Q_OS_SYMBIAN ) + QSKIP("Symbian: QProcess IO is not yet supported, fix when supported", 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); + +#if defined(Q_OS_VXWORKS) + QSKIP("VxSim in standard config doesn't even run a DNS resolver", SkipAll); +#else + 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(2000)); + QVERIFY(stopWatch.elapsed() < 2000); + QCOMPARE(socket->error(), QAbstractSocket::SocketTimeoutError); + + delete socket; +#endif +} + +//---------------------------------------------------------------------------------- +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(5000)); + 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(5000)); + 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(5000)); + 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(5000)); + socket->write("XXX LOGOUT\r\n"); + QVERIFY(socket->waitForBytesWritten(5000)); + socket->moveToThread(0); + QVERIFY(socket->waitForDisconnected()); + delete socket; + } +} + +void tst_QTcpSocket::increaseReadBufferSize() +{ + QFETCH_GLOBAL(bool, setProxy); + if (setProxy) + return; //proxy not useful for localhost test case + 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; +} + +void tst_QTcpSocket::taskQtBug5799ConnectionErrorWaitForConnected() +{ + QFETCH_GLOBAL(bool, setProxy); + if (setProxy) + return; + + // check that we get a proper error connecting to port 12346 + // use waitForConnected, e.g. this should use a synchronous select() on the OS level + + QTcpSocket socket; + socket.connectToHost(QtNetworkSettings::serverName(), 12346); + QTime timer; + timer.start(); + socket.waitForConnected(10000); + QVERIFY2(timer.elapsed() < 9900, "Connection to closed port timed out instead of refusing, something is wrong"); + QVERIFY2(socket.state() == QAbstractSocket::UnconnectedState, "Socket connected unexpectedly!"); + QVERIFY2(socket.error() == QAbstractSocket::ConnectionRefusedError, + QString("Could not reach server: %1").arg(socket.errorString()).toLocal8Bit()); +} + +void tst_QTcpSocket::taskQtBug5799ConnectionErrorEventLoop() +{ + QFETCH_GLOBAL(bool, setProxy); + if (setProxy) + return; + + // check that we get a proper error connecting to port 12346 + // This testcase uses an event loop + QTcpSocket socket; + connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), &QTestEventLoop::instance(), SLOT(exitLoop())); + socket.connectToHost(QtNetworkSettings::serverName(), 12346); + + QTestEventLoop::instance().enterLoop(10); + QVERIFY2(!QTestEventLoop::instance().timeout(), "Connection to closed port timed out instead of refusing, something is wrong"); + QVERIFY2(socket.state() == QAbstractSocket::UnconnectedState, "Socket connected unexpectedly!"); + QVERIFY2(socket.error() == QAbstractSocket::ConnectionRefusedError, + QString("Could not reach server: %1").arg(socket.errorString()).toLocal8Bit()); +} + +void tst_QTcpSocket::taskQtBug7054TimeoutErrorResetting() +{ + QTcpSocket *socket = newSocket(); + + socket->connectToHost(QtNetworkSettings::serverName(), 443); + QVERIFY(socket->waitForConnected(5*1000)); + QVERIFY(socket->error() == QAbstractSocket::UnknownSocketError); + + // We connected to the HTTPS port. Wait two seconds to receive data. We will receive + // nothing because we would need to start the SSL handshake + QVERIFY(!socket->waitForReadyRead(2*1000)); + QVERIFY(socket->error() == QAbstractSocket::SocketTimeoutError); + + // Now write some crap to make the server disconnect us. 4 lines are enough. + socket->write("a\r\nb\r\nc\r\nd\r\n"); + socket->waitForBytesWritten(2*1000); + + // we try to waitForReadyRead another time, but this time instead of a timeout we + // should get a better error since the server disconnected us + QVERIFY(!socket->waitForReadyRead(2*1000)); + // It must NOT be the SocketTimeoutError that had been set before + QVERIFY(socket->error() == QAbstractSocket::RemoteHostClosedError); +} + +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); +#if !defined(Q_OS_SYMBIAN) + 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); +#endif +} + +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(5000)); + } + 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(5000)); + 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; +} + +// there is a similar test inside tst_qtcpserver that uses the event loop instead +void tst_QTcpSocket::qtbug14268_peek() +{ + QFETCH_GLOBAL(bool, setProxy); + if (setProxy) + return; + + SocketPair socketPair; + QVERIFY(socketPair.create()); + QTcpSocket *outgoing = socketPair.endPoints[0]; + QTcpSocket *incoming = socketPair.endPoints[1]; + + QVERIFY(incoming->state() == QTcpSocket::ConnectedState); + QVERIFY(outgoing->state() == QTcpSocket::ConnectedState); + + outgoing->write("abc\n"); + QVERIFY(outgoing->waitForBytesWritten(2000)); + QVERIFY(incoming->waitForReadyRead(2000)); + QVERIFY(incoming->peek(128*1024) == QByteArray("abc\n")); + + outgoing->write("def\n"); + QVERIFY(outgoing->waitForBytesWritten(2000)); + QVERIFY(incoming->waitForReadyRead(2000)); + QVERIFY(incoming->peek(128*1024) == QByteArray("abc\ndef\n")); + + outgoing->write("ghi\n"); + QVERIFY(outgoing->waitForBytesWritten(2000)); + QVERIFY(incoming->waitForReadyRead(2000)); + QVERIFY(incoming->peek(128*1024) == QByteArray("abc\ndef\nghi\n")); + + QVERIFY(incoming->read(128*1024) == QByteArray("abc\ndef\nghi\n")); +} + + + +QTEST_MAIN(tst_QTcpSocket) +#include "tst_qtcpsocket.moc" |