1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 #include <QtTest/QtTest>

    44 #include <QtCore/QCryptographicHash>

    45 #include <QtCore/QDataStream>

    46 #include <QtCore/QUrl>

    47 #include <QtCore/QEventLoop>

    48 #include <QtCore/QFile>

    49 #include <QtCore/QSharedPointer>

    50 #include <QtCore/QTemporaryFile>

    51 #include <QtNetwork/QTcpServer>

    52 #include <QtNetwork/QTcpSocket>

    53 #include <QtNetwork/QLocalSocket>

    54 #include <QtNetwork/QLocalServer>

    55 #include <QtNetwork/QHostInfo>

    56 #include <QtNetwork/QFtp>

    57 #include <QtNetwork/qauthenticator.h>

    58 #include <QtNetwork/qnetworkaccessmanager.h>

    59 #include <QtNetwork/qnetworkrequest.h>

    60 #include <QtNetwork/qnetworkreply.h>

    61 #include <QtNetwork/qnetworkcookie.h>

    62 #ifndef QT_NO_OPENSSL

    63 #include <QtNetwork/qsslerror.h>

    64 #include <QtNetwork/qsslconfiguration.h>

    65 #endif

    66 

    67 #include <time.h>

    68 

    69 #include "private/qnetworkaccessmanager_p.h"

    70 

    71 #ifdef Q_OS_SYMBIAN

    72 #define SRCDIR "."

    73 #endif

    74 

    75 #include "../network-settings.h"

    76 

    77 

    78 Q_DECLARE_METATYPE(QNetworkReply*)

    79 Q_DECLARE_METATYPE(QAuthenticator*)

    80 Q_DECLARE_METATYPE(QNetworkProxy)

    81 Q_DECLARE_METATYPE(QNetworkProxyQuery)

    82 Q_DECLARE_METATYPE(QList<QNetworkProxy>)

    83 Q_DECLARE_METATYPE(QNetworkReply::NetworkError)

    84 

    85 class QNetworkReplyPtr: public QSharedPointer<QNetworkReply>

    86 {

    87 public:

    88     inline QNetworkReplyPtr(QNetworkReply *ptr = 0)

    89         : QSharedPointer<QNetworkReply>(ptr)

    90     { }

    91 

    92     inline operator QNetworkReply *() const { return data(); }

    93 };

    94 

    95 class MyCookieJar;

    96 class tst_QNetworkReply: public QObject

    97 {

    98     Q_OBJECT

    99 

   100     struct ProxyData {

   101         ProxyData(const QNetworkProxy &p, const QByteArray &t, bool auth)

   102             : tag(t), proxy(p), requiresAuthentication(auth)

   103         { }

   104         QByteArray tag;

   105         QNetworkProxy proxy;

   106         bool requiresAuthentication;

   107     };

   108 

   109     QEventLoop *loop;

   110     enum RunSimpleRequestReturn { Timeout = 0, Success, Failure };

   111     int returnCode;

   112     QString testFileName;

   113 #if !defined Q_OS_WIN

   114     QString wronlyFileName;

   115 #endif

   116     QString uniqueExtension;

   117     QList<ProxyData> proxies;

   118     QNetworkAccessManager manager;

   119     MyCookieJar *cookieJar;

   120 #ifndef QT_NO_OPENSSL

   121     QSslConfiguration storedSslConfiguration;

   122     QList<QSslError> storedExpectedSslErrors;

   123 #endif

   124 

   125 public:

   126     tst_QNetworkReply();

   127     ~tst_QNetworkReply();

   128     QString runSimpleRequest(QNetworkAccessManager::Operation op, const QNetworkRequest &request,

   129                              QNetworkReplyPtr &reply, const QByteArray &data = QByteArray());

   130 

   131 public Q_SLOTS:

   132     void finished();

   133     void gotError();

   134     void authenticationRequired(QNetworkReply*,QAuthenticator*);

   135     void proxyAuthenticationRequired(const QNetworkProxy &,QAuthenticator*);

   136 

   137 #ifndef QT_NO_OPENSSL

   138     void sslErrors(QNetworkReply*,const QList<QSslError> &);

   139     void storeSslConfiguration();

   140     void ignoreSslErrorListSlot(QNetworkReply *reply, const QList<QSslError> &);

   141 #endif

   142 

   143 protected Q_SLOTS:

   144     void nestedEventLoops_slot();

   145 

   146 private Q_SLOTS:

   147     void init();

   148     void cleanup();

   149     void initTestCase();

   150     void cleanupTestCase();

   151 

   152     void stateChecking();

   153     void invalidProtocol();

   154     void getFromData_data();

   155     void getFromData();

   156     void getFromFile();

   157     void getFromFileSpecial_data();

   158     void getFromFileSpecial();

   159     void getFromFtp_data();

   160     void getFromFtp();

   161     void getFromHttp_data();

   162     void getFromHttp();

   163     void getErrors_data();

   164     void getErrors();

   165     void putToFile_data();

   166     void putToFile();

   167     void putToFtp_data();

   168     void putToFtp();

   169     void putToHttp_data();

   170     void putToHttp();

   171     void postToHttp_data();

   172     void postToHttp();

   173     void deleteFromHttp_data();

   174     void deleteFromHttp();

   175     void putGetDeleteGetFromHttp_data();

   176     void putGetDeleteGetFromHttp();

   177 

   178     void ioGetFromData_data();

   179     void ioGetFromData();

   180     void ioGetFromFileSpecial_data();

   181     void ioGetFromFileSpecial();

   182     void ioGetFromFile_data();

   183     void ioGetFromFile();

   184     void ioGetFromFtp_data();

   185     void ioGetFromFtp();

   186     void ioGetFromFtpWithReuse();

   187     void ioGetFromHttp();

   188 

   189     void ioGetFromHttpWithReuseParallel();

   190     void ioGetFromHttpWithReuseSequential();

   191     void ioGetFromHttpWithAuth();

   192     void ioGetFromHttpWithProxyAuth();

   193     void ioGetFromHttpWithSocksProxy();

   194 #ifndef QT_NO_OPENSSL

   195     void ioGetFromHttpsWithSslErrors();

   196     void ioGetFromHttpsWithIgnoreSslErrors();

   197     void ioGetFromHttpsWithSslHandshakeError();

   198 #endif

   199     void ioGetFromHttpBrokenServer_data();

   200     void ioGetFromHttpBrokenServer();

   201 

   202     void ioGetWithManyProxies_data();

   203     void ioGetWithManyProxies();

   204 

   205     void ioPutToFileFromFile_data();

   206     void ioPutToFileFromFile();

   207     void ioPutToFileFromSocket_data();

   208     void ioPutToFileFromSocket();

   209     void ioPutToFileFromLocalSocket_data();

   210     void ioPutToFileFromLocalSocket();

   211     void ioPutToFileFromProcess_data();

   212     void ioPutToFileFromProcess();

   213     void ioPutToFtpFromFile_data();

   214     void ioPutToFtpFromFile();

   215     void ioPutToHttpFromFile_data();

   216     void ioPutToHttpFromFile();

   217     void ioPostToHttpFromFile_data();

   218     void ioPostToHttpFromFile();

   219     void ioPostToHttpFromSocket_data();

   220     void ioPostToHttpFromSocket();

   221     void ioPostToHttpFromMiddleOfFileToEnd();

   222     void ioPostToHttpFromMiddleOfFileFiveBytes();

   223     void ioPostToHttpFromMiddleOfQBufferFiveBytes();

   224     void ioPostToHttpNoBufferFlag();

   225     void ioPostToHttpUploadProgress();

   226     void ioPostToHttpEmtpyUploadProgress();

   227 

   228     void rateControl_data();

   229     void rateControl();

   230     void downloadPerformance();

   231     void uploadPerformance();

   232     void performanceControlRate();

   233     void httpUploadPerformance();

   234     void httpDownloadPerformance_data();

   235     void httpDownloadPerformance();

   236 

   237     void downloadProgress_data();

   238     void downloadProgress();

   239     void uploadProgress_data();

   240     void uploadProgress();

   241 

   242     void chaining_data();

   243     void chaining();

   244 

   245     void receiveCookiesFromHttp_data();

   246     void receiveCookiesFromHttp();

   247     void sendCookies_data();

   248     void sendCookies();

   249 

   250     void nestedEventLoops();

   251 

   252     void httpProxyCommands_data();

   253     void httpProxyCommands();

   254     void proxyChange();

   255     void authorizationError_data();

   256     void authorizationError();

   257 

   258     void httpConnectionCount();

   259 

   260 #ifndef QT_NO_OPENSSL

   261     void ioPostToHttpsUploadProgress();

   262     void ignoreSslErrorsList_data();

   263     void ignoreSslErrorsList();

   264     void ignoreSslErrorsListWithSlot_data();

   265     void ignoreSslErrorsListWithSlot();

   266 #endif

   267 };

   268 

   269 QT_BEGIN_NAMESPACE

   270 

   271 namespace QTest {

   272     template<>

   273     char *toString(const QNetworkReply::NetworkError& code)

   274     {

   275         const QMetaObject *mo = &QNetworkReply::staticMetaObject;

   276         int index = mo->indexOfEnumerator("NetworkError");

   277         if (index == -1)

   278             return qstrdup("");

   279 

   280         QMetaEnum qme = mo->enumerator(index);

   281         return qstrdup(qme.valueToKey(code));

   282     }

   283 

   284     template<>

   285     char *toString(const QNetworkCookie &cookie)

   286     {

   287         return qstrdup(cookie.toRawForm());

   288     }

   289 

   290     template<>

   291     char *toString(const QList<QNetworkCookie> &list)

   292     {

   293         QString result = "QList(";

   294         bool first = true;

   295         foreach (QNetworkCookie cookie, list) {

   296             if (!first)

   297                 result += ", ";

   298             first = false;

   299             result += QString::fromLatin1("QNetworkCookie(%1)").arg(QLatin1String(cookie.toRawForm()));

   300         }

   301 

   302         return qstrdup(result.append(')').toLocal8Bit());

   303     }

   304 }

   305 

   306 QT_END_NAMESPACE

   307 

   308 #define RUN_REQUEST(call)                       \

   309     do {                                        \

   310         QString errorMsg = call;                \

   311         if (!errorMsg.isEmpty())                \

   312             QFAIL(qPrintable(errorMsg));        \

   313     } while (0);

   314 

   315 class MiniHttpServer: public QTcpServer

   316 {

   317     Q_OBJECT

   318     QTcpSocket *client;

   319 

   320 public:

   321     QByteArray dataToTransmit;

   322     QByteArray receivedData;

   323     bool doClose;

   324 

   325     MiniHttpServer(const QByteArray &data) : client(0), dataToTransmit(data), doClose(true)

   326     {

   327         listen();

   328         connect(this, SIGNAL(newConnection()), this, SLOT(doAccept()));

   329     }

   330 

   331 public slots:

   332     void doAccept()

   333     {

   334         client = nextPendingConnection();

   335         connect(client, SIGNAL(readyRead()), this, SLOT(sendData()));

   336     }

   337 

   338     void sendData()

   339     {

   340         receivedData += client->readAll();

   341         if (receivedData.contains("\r\n\r\n") ||

   342             receivedData.contains("\n\n")) {

   343             client->write(dataToTransmit);

   344             if (doClose) {

   345                 client->disconnectFromHost();

   346                 disconnect(client, 0, this, 0);

   347                 client = 0;

   348             }

   349         }

   350     }

   351 };

   352 

   353 class MyCookieJar: public QNetworkCookieJar

   354 {

   355 public:

   356     inline QList<QNetworkCookie> allCookies() const

   357         { return QNetworkCookieJar::allCookies(); }

   358     inline void setAllCookies(const QList<QNetworkCookie> &cookieList)

   359         { QNetworkCookieJar::setAllCookies(cookieList); }

   360 };

   361 

   362 class MyProxyFactory: public QNetworkProxyFactory

   363 {

   364 public:

   365     int callCount;

   366     QList<QNetworkProxy> toReturn;

   367     QNetworkProxyQuery lastQuery;

   368     inline MyProxyFactory() { clear(); }

   369 

   370     inline void clear()

   371     {

   372         callCount = 0;

   373         toReturn = QList<QNetworkProxy>() << QNetworkProxy::DefaultProxy;

   374         lastQuery = QNetworkProxyQuery();

   375     }

   376 

   377     virtual QList<QNetworkProxy> queryProxy(const QNetworkProxyQuery &query)

   378     {

   379         lastQuery = query;

   380         ++callCount;

   381         return toReturn;

   382     }

   383 };

   384 

   385 class DataReader: public QObject

   386 {

   387     Q_OBJECT

   388 public:

   389     qint64 totalBytes;

   390     QByteArray data;

   391     QIODevice *device;

   392     bool accumulate;

   393     DataReader(QIODevice *dev, bool acc = true) : totalBytes(0), device(dev), accumulate(acc)

   394     {

   395         connect(device, SIGNAL(readyRead()), SLOT(doRead()));

   396     }

   397 

   398 public slots:

   399     void doRead()

   400     {

   401         QByteArray buffer;

   402         buffer.resize(device->bytesAvailable());

   403         qint64 bytesRead = device->read(buffer.data(), device->bytesAvailable());

   404         if (bytesRead == -1) {

   405             QTestEventLoop::instance().exitLoop();

   406             return;

   407         }

   408         buffer.truncate(bytesRead);

   409         totalBytes += bytesRead;

   410 

   411         if (accumulate)

   412             data += buffer;

   413     }

   414 };

   415 

   416 class FixedSizeDataGenerator : public QIODevice

   417 {

   418     Q_OBJECT

   419     enum { Idle, Started, Stopped } state;

   420 public:

   421     FixedSizeDataGenerator(qint64 size) : state(Idle)

   422     { open(ReadOnly | Unbuffered);

   423       toBeGeneratedTotalCount = toBeGeneratedCount = size;

   424     }

   425 

   426     virtual qint64 bytesAvailable() const

   427     {

   428         return state == Started ? toBeGeneratedCount + QIODevice::bytesAvailable() : 0;

   429     }

   430 

   431     virtual bool isSequential() const{

   432         return false;

   433     }

   434 

   435     virtual bool reset() const{

   436         return false;

   437     }

   438 

   439     qint64 size() const {

   440         return toBeGeneratedTotalCount;

   441     }

   442 

   443 public slots:

   444     void start() { state = Started; emit readyRead(); }

   445 

   446 protected:

   447     virtual qint64 readData(char *data, qint64 maxlen)

   448     {

   449         memset(data, '@', maxlen);

   450 

   451         if (toBeGeneratedCount <= 0) {

   452             return -1;

   453         }

   454 

   455         qint64 n = qMin(maxlen, toBeGeneratedCount);

   456         toBeGeneratedCount -= n;

   457 

   458         if (toBeGeneratedCount <= 0) {

   459             // make sure this is a queued connection!

   460             emit readChannelFinished();

   461         }

   462 

   463         return n;

   464     }

   465     virtual qint64 writeData(const char *, qint64)

   466     { return -1; }

   467 

   468     qint64 toBeGeneratedCount;

   469     qint64 toBeGeneratedTotalCount;

   470 };

   471 

   472 

   473 class DataGenerator: public QIODevice

   474 {

   475     Q_OBJECT

   476     enum { Idle, Started, Stopped } state;

   477 public:

   478     DataGenerator() : state(Idle)

   479     { open(ReadOnly); }

   480 

   481     virtual bool isSequential() const { return true; }

   482     virtual qint64 bytesAvailable() const { return state == Started ? 1024*1024 : 0; }

   483 

   484 public slots:

   485     void start() { state = Started; emit readyRead(); }

   486     void stop() { state = Stopped; emit readyRead(); }

   487 

   488 protected:

   489     virtual qint64 readData(char *data, qint64 maxlen)

   490     {

   491         if (state == Stopped)

   492             return -1;          // EOF

   493 

   494         // return as many bytes as are wanted

   495         memset(data, '@', maxlen);

   496         return maxlen;

   497     }

   498     virtual qint64 writeData(const char *, qint64)

   499     { return -1; }

   500 };

   501 

   502 

   503 

   504 class SocketPair: public QObject

   505 {

   506     Q_OBJECT

   507 public:

   508     QIODevice *endPoints[2];

   509 

   510     SocketPair(QObject *parent = 0)

   511         : QObject(parent)

   512     {

   513         endPoints[0] = endPoints[1] = 0;

   514     }

   515 

   516     bool create()

   517     {

   518         QTcpServer server;

   519         server.listen();

   520 

   521         QTcpSocket *active = new QTcpSocket(this);

   522         active->connectToHost("127.0.0.1", server.serverPort());

   523 #ifndef Q_OS_SYMBIAN

   524         // need more time as working with embedded

   525 		// device and testing from emualtor

   526 		// things tend to get slower

   527         if (!active->waitForConnected(1000))

   528             return false;

   529 

   530         if (!server.waitForNewConnection(1000))

   531             return false;

   532 #else

   533         if (!active->waitForConnected(100))

   534             return false;

   535 

   536         if (!server.waitForNewConnection(100))

   537             return false;

   538 #endif

   539         QTcpSocket *passive = server.nextPendingConnection();

   540         passive->setParent(this);

   541 

   542         endPoints[0] = active;

   543         endPoints[1] = passive;

   544         return true;

   545     }

   546 };

   547 

   548 class FastSender: public QThread

   549 {

   550     Q_OBJECT

   551     QSemaphore ready;

   552     qint64 wantedSize;

   553     int port;

   554 public:

   555     int transferRate;

   556     QWaitCondition cond;

   557     FastSender(qint64 size)

   558         : wantedSize(size), port(-1), transferRate(-1)

   559     {

   560         start();

   561         ready.acquire();

   562     }

   563 

   564     inline int serverPort() const { return port; }

   565 

   566 protected:

   567     void run()

   568     {

   569         QTcpServer server;

   570         server.listen();

   571         port = server.serverPort();

   572         ready.release();

   573 

   574         server.waitForNewConnection(-1);

   575         QTcpSocket *client = server.nextPendingConnection();

   576 

   577         // get the "request" packet

   578         if (!client->waitForReadyRead(2000)) {

   579             qDebug() << client->error() << "waiting for \"request\" packet";

   580             return;

   581         }

   582         client->readAll();      // we're not interested in the actual contents

   583 

   584         enum { BlockSize = 256 };

   585         QByteArray data;

   586         {

   587             QDataStream stream(&data, QIODevice::WriteOnly);

   588             stream << QVariantMap() << QByteArray(BlockSize, 'a');

   589         }

   590         qint32 size = data.size();

   591 

   592         // write a bunch of bytes to fill up the buffers

   593         do {

   594             client->write((char*)&size, sizeof size);

   595             client->write(data);

   596             while (client->bytesToWrite() > 0)

   597                 if (!client->waitForBytesWritten(0))

   598                     break;

   599         } while (client->bytesToWrite() == 0);

   600 

   601         // the kernel buffer is full

   602         // clean up QAbstractSocket's residue:

   603         while (client->bytesToWrite() > 0)

   604             if (!client->waitForBytesWritten(2000)) {

   605                 qDebug() << client->error() << "cleaning up residue";

   606                 return;

   607             }

   608 

   609         // now write in "blocking mode"

   610         QTime timer;

   611         timer.start();

   612         qint64 totalBytes = 0;

   613         while (totalBytes < wantedSize) {

   614             int bytesToWrite = wantedSize - totalBytes;

   615             Q_ASSERT(bytesToWrite);

   616             if (bytesToWrite > BlockSize) {

   617                 bytesToWrite = BlockSize;

   618             } else {

   619                 QDataStream stream(&data, QIODevice::WriteOnly);

   620                 stream << QVariantMap() << QByteArray(bytesToWrite, 'b');

   621             }

   622             size = data.size();

   623             client->write((char*)&size, sizeof size);

   624             client->write(data);

   625             totalBytes += bytesToWrite;

   626 

   627             while (client->bytesToWrite() > 0)

   628                 if (!client->waitForBytesWritten(2000)) {

   629                     qDebug() << client->error() << "blocking write";

   630                     return;

   631                 }

   632 //            qDebug() << bytesToWrite << "bytes written now;"

   633 //                     << totalBytes << "total ("

   634 //                     << totalBytes*100/wantedSize << "% complete);"

   635 //                     << timer.elapsed() << "ms elapsed";

   636         }

   637 

   638         transferRate = totalBytes * 1000 / timer.elapsed();

   639         qDebug() << "flushed" << totalBytes << "bytes in" << timer.elapsed() << "ms: rate =" << transferRate;

   640 

   641         // write a "close connection" packet

   642         {

   643             QDataStream stream(&data, QIODevice::WriteOnly);

   644             stream << QVariantMap() << QByteArray();

   645         }

   646         size = data.size();

   647         client->write((char*)&size, sizeof size);

   648         client->write(data);

   649     }

   650 };

   651 

   652 class RateControlledReader: public QObject

   653 {

   654     Q_OBJECT

   655     QIODevice *device;

   656     int bytesToRead;

   657     int interval;

   658 public:

   659     qint64 totalBytesRead;

   660     RateControlledReader(QIODevice *dev, int kbPerSec)

   661         : device(dev), totalBytesRead(0)

   662     {

   663         // determine how often we have to wake up

   664         bytesToRead = kbPerSec * 1024 / 20;

   665         interval = 50;

   666 

   667         qDebug() << "RateControlledReader: going to read" << bytesToRead

   668                  << "bytes every" << interval << "ms";

   669         qDebug() << "actual rate will be"

   670                  << (bytesToRead * 1000 / interval) << "bytes/sec (wanted"

   671                  << kbPerSec * 1024 << "bytes/sec)";

   672         startTimer(interval);

   673     }

   674 

   675 protected:

   676     void timerEvent(QTimerEvent *)

   677     {

   678         qint64 bytesRead = 0;

   679         QTime stopWatch;

   680         stopWatch.start();

   681         do {

   682             if (device->bytesAvailable() == 0)

   683                 if (stopWatch.elapsed() > 10 || !device->waitForReadyRead(5))

   684                     break;

   685             QByteArray data = device->read(bytesToRead - bytesRead);

   686             bytesRead += data.size();

   687         } while (bytesRead < bytesToRead);// && stopWatch.elapsed() < interval/4);

   688         totalBytesRead += bytesRead;

   689 

   690         if (bytesRead < bytesToRead)

   691             qWarning() << bytesToRead - bytesRead << "bytes not read";

   692     }

   693 };

   694 

   695 class TimedSender: public QThread

   696 {

   697     Q_OBJECT

   698     qint64 totalBytes;

   699     QSemaphore ready;

   700     QByteArray dataToSend;

   701     QTcpSocket *client;

   702     int timeout;

   703     int port;

   704 public:

   705     int transferRate;

   706     TimedSender(int ms)

   707         : totalBytes(0), timeout(ms), port(-1), transferRate(-1)

   708     {

   709         dataToSend = QByteArray(16*1024, '@');

   710         start();

   711         ready.acquire();

   712     }

   713 

   714     inline int serverPort() const { return port; }

   715 

   716 private slots:

   717     void writeMore()

   718     {

   719         while (client->bytesToWrite() < 128 * 1024) {

   720             writePacket(dataToSend);

   721         }

   722     }

   723 

   724 protected:

   725     void run()

   726     {

   727         QTcpServer server;

   728         server.listen();

   729         port = server.serverPort();

   730         ready.release();

   731 

   732         server.waitForNewConnection(-1);

   733         client = server.nextPendingConnection();

   734 

   735         writeMore();

   736         connect(client, SIGNAL(bytesWritten(qint64)), SLOT(writeMore()), Qt::DirectConnection);

   737 

   738         QEventLoop eventLoop;

   739         QTimer::singleShot(timeout, &eventLoop, SLOT(quit()));

   740 

   741         QTime timer;

   742         timer.start();

   743         eventLoop.exec();

   744         disconnect(client, SIGNAL(bytesWritten(qint64)), this, 0);

   745 

   746         // wait for the connection to shut down

   747         client->disconnectFromHost();

   748         if (!client->waitForDisconnected(10000))

   749             return;

   750 

   751         transferRate = totalBytes * 1000 / timer.elapsed();

   752         qDebug() << "TimedSender::run" << "receive rate:" << (transferRate / 1024) << "kB/s in"

   753                  << timer.elapsed() << "ms";

   754     }

   755 

   756     void writePacket(const QByteArray &array)

   757     {

   758         client->write(array);

   759         totalBytes += array.size();

   760     }

   761 };

   762 

   763 class ThreadedDataReader: public QThread

   764 {

   765     Q_OBJECT

   766     // used to make the constructor only return after the tcp server started listening

   767     QSemaphore ready;

   768     QTcpSocket *client;

   769     int timeout;

   770     int port;

   771 public:

   772     qint64 transferRate;

   773     ThreadedDataReader()

   774         : port(-1), transferRate(-1)

   775     {

   776         start();

   777         ready.acquire();

   778     }

   779 

   780     inline int serverPort() const { return port; }

   781 

   782 protected:

   783     void run()

   784     {

   785         QTcpServer server;

   786         server.listen();

   787         port = server.serverPort();

   788         ready.release();

   789 

   790         server.waitForNewConnection(-1);

   791         client = server.nextPendingConnection();

   792 

   793         QEventLoop eventLoop;

   794         DataReader reader(client, false);

   795         QObject::connect(client, SIGNAL(disconnected()), &eventLoop, SLOT(quit()));

   796 

   797         QTime timer;

   798         timer.start();

   799         eventLoop.exec();

   800         qint64 elapsed = timer.elapsed();

   801 

   802         transferRate = reader.totalBytes * 1000 / elapsed;

   803         qDebug() << "ThreadedDataReader::run" << "send rate:" << (transferRate / 1024) << "kB/s in" << elapsed << "msec";

   804     }

   805 };

   806 

   807 class ThreadedDataReaderHttpServer: public QThread

   808 {

   809     Q_OBJECT

   810     // used to make the constructor only return after the tcp server started listening

   811     QSemaphore ready;

   812     QTcpSocket *client;

   813     int timeout;

   814     int port;

   815 public:

   816     qint64 transferRate;

   817     ThreadedDataReaderHttpServer()

   818         : port(-1), transferRate(-1)

   819     {

   820         start();

   821         ready.acquire();

   822     }

   823 

   824     inline int serverPort() const { return port; }

   825 

   826 protected:

   827     void run()

   828     {

   829         QTcpServer server;

   830         server.listen();

   831         port = server.serverPort();

   832         ready.release();

   833 

   834         server.waitForNewConnection(-1);

   835         client = server.nextPendingConnection();

   836         client->write("HTTP/1.0 200 OK\r\n");

   837         client->write("Content-length: 0\r\n");

   838         client->write("\r\n");

   839         client->flush();

   840 

   841         QCoreApplication::processEvents();

   842 

   843         QEventLoop eventLoop;

   844         DataReader reader(client, false);

   845         QObject::connect(client, SIGNAL(disconnected()), &eventLoop, SLOT(quit()));

   846 

   847         QTime timer;

   848         timer.start();

   849         eventLoop.exec();

   850         qint64 elapsed = timer.elapsed();

   851 

   852         transferRate = reader.totalBytes * 1000 / elapsed;

   853         qDebug() << "ThreadedDataReaderHttpServer::run" << "send rate:" << (transferRate / 1024) << "kB/s in" << elapsed << "msec";

   854     }

   855 };

   856 

   857 class HttpDownloadPerformanceClient : QObject {

   858     Q_OBJECT;

   859     QIODevice *device;

   860     public:

   861     HttpDownloadPerformanceClient (QIODevice *dev) : device(dev){

   862         connect(dev, SIGNAL(readyRead()), this, SLOT(readyReadSlot()));

   863     }

   864 

   865     public slots:

   866     void readyReadSlot() {

   867         device->readAll();

   868     }

   869 

   870 };

   871 

   872 class HttpDownloadPerformanceServer : QObject {

   873     Q_OBJECT;

   874     qint64 dataSize;

   875     qint64 dataSent;

   876     QTcpServer server;

   877     QTcpSocket *client;

   878     bool serverSendsContentLength;

   879     bool chunkedEncoding;

   880 

   881 public:

   882     HttpDownloadPerformanceServer (qint64 ds, bool sscl, bool ce) : dataSize(ds), dataSent(0),

   883     client(0), serverSendsContentLength(sscl), chunkedEncoding(ce) {

   884         server.listen();

   885         connect(&server, SIGNAL(newConnection()), this, SLOT(newConnectionSlot()));

   886     }

   887 

   888     int serverPort() {

   889         return server.serverPort();

   890     }

   891 

   892 public slots:

   893 

   894     void newConnectionSlot() {

   895         client = server.nextPendingConnection();

   896         client->setParent(this);

   897         connect(client, SIGNAL(readyRead()), this, SLOT(readyReadSlot()));

   898         connect(client, SIGNAL(bytesWritten(qint64)), this, SLOT(bytesWrittenSlot(qint64)));

   899     }

   900 

   901     void readyReadSlot() {

   902         client->readAll();

   903         client->write("HTTP/1.0 200 OK\n");

   904         if (serverSendsContentLength)

   905             client->write(QString("Content-Length: " + QString::number(dataSize) + "\n").toAscii());

   906         if (chunkedEncoding)

   907             client->write(QString("Transfer-Encoding: chunked\n").toAscii());

   908         client->write("Connection: close\n\n");

   909     }

   910 

   911     void bytesWrittenSlot(qint64 amount) {

   912         Q_UNUSED(amount);

   913         if (dataSent == dataSize && client) {

   914             // close eventually

   915 

   916             // chunked encoding: we have to send a last "empty" chunk

   917             if (chunkedEncoding)

   918                 client->write(QString("0\r\n\r\n").toAscii());

   919 

   920             client->disconnectFromHost();

   921             server.close();

   922             client = 0;

   923             return;

   924         }

   925 

   926         // send data

   927         if (client && client->bytesToWrite() < 100*1024 && dataSent < dataSize) {

   928             qint64 amount = qMin(qint64(16*1024), dataSize - dataSent);

   929             QByteArray data(amount, '@');

   930 

   931             if (chunkedEncoding) {

   932                 client->write(QString(QString("%1").arg(amount,0,16).toUpper() + "\r\n").toAscii());

   933                 client->write(data.constData(), amount);

   934                 client->write(QString("\r\n").toAscii());

   935             } else {

   936                 client->write(data.constData(), amount);

   937             }

   938 

   939             dataSent += amount;

   940         }

   941     }

   942 };

   943 

   944 

   945 tst_QNetworkReply::tst_QNetworkReply()

   946 {

   947     Q_SET_DEFAULT_IAP

   948 

   949     testFileName = QDir::currentPath() + "/testfile";

   950 #ifndef Q_OS_WINCE

   951     uniqueExtension = QString("%1%2%3").arg((qulonglong)this).arg(rand()).arg((qulonglong)time(0));

   952 #else

   953     uniqueExtension = QString("%1%2").arg((qulonglong)this).arg(rand());

   954 #endif

   955     cookieJar = new MyCookieJar;

   956     manager.setCookieJar(cookieJar);

   957 

   958     QHostInfo hostInfo = QHostInfo::fromName(QtNetworkSettings::serverName());

   959 

   960     proxies << ProxyData(QNetworkProxy::NoProxy, "", false);

   961 

   962     if (hostInfo.error() == QHostInfo::NoError && !hostInfo.addresses().isEmpty()) {

   963         QString proxyserver = hostInfo.addresses().first().toString();

   964         proxies << ProxyData(QNetworkProxy(QNetworkProxy::HttpProxy, proxyserver, 3128), "+proxy", false)

   965                 << ProxyData(QNetworkProxy(QNetworkProxy::HttpProxy, proxyserver, 3129), "+proxyauth", true)

   966                 // currently unsupported

   967                 // << ProxyData(QNetworkProxy(QNetworkProxy::HttpProxy, proxyserver, 3130), "+proxyauth-ntlm", true);

   968                 << ProxyData(QNetworkProxy(QNetworkProxy::Socks5Proxy, proxyserver, 1080), "+socks", false)

   969                 << ProxyData(QNetworkProxy(QNetworkProxy::Socks5Proxy, proxyserver, 1081), "+socksauth", true);

   970     } else {

   971         printf("==================================================================\n");

   972         printf("Proxy could not be looked up. No proxy will be used while testing!\n");

   973         printf("==================================================================\n");

   974     }

   975 }

   976 

   977 tst_QNetworkReply::~tst_QNetworkReply()

   978 {

   979 }

   980 

   981 

   982 void tst_QNetworkReply::authenticationRequired(QNetworkReply*, QAuthenticator* auth)

   983 {

   984     auth->setUser("httptest");

   985     auth->setPassword("httptest");

   986 }

   987 

   988 void tst_QNetworkReply::proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator* auth)

   989 {

   990     auth->setUser("qsockstest");

   991     auth->setPassword("password");

   992 }

   993 

   994 #ifndef QT_NO_OPENSSL

   995 void tst_QNetworkReply::sslErrors(QNetworkReply *reply, const QList<QSslError> &errors)

   996 {

   997     reply->ignoreSslErrors();

   998     QVERIFY(!errors.isEmpty());

   999     QVERIFY(!reply->sslConfiguration().isNull());

  1000 }

  1001 

  1002 void tst_QNetworkReply::storeSslConfiguration()

  1003 {

  1004     storedSslConfiguration = QSslConfiguration();

  1005     QNetworkReply *reply = qobject_cast<QNetworkReply *>(sender());

  1006     if (reply)

  1007         storedSslConfiguration = reply->sslConfiguration();

  1008 }

  1009 #endif

  1010 

  1011 QString tst_QNetworkReply::runSimpleRequest(QNetworkAccessManager::Operation op,

  1012                                             const QNetworkRequest &request,

  1013                                             QNetworkReplyPtr &reply,

  1014                                             const QByteArray &data)

  1015 {

  1016     switch (op) {

  1017     case QNetworkAccessManager::HeadOperation:

  1018         reply = manager.head(request);

  1019         break;

  1020 

  1021     case QNetworkAccessManager::GetOperation:

  1022         reply = manager.get(request);

  1023         break;

  1024 

  1025     case QNetworkAccessManager::PutOperation:

  1026         reply = manager.put(request, data);

  1027         break;

  1028 

  1029     case QNetworkAccessManager::PostOperation:

  1030         reply = manager.post(request, data);

  1031         break;

  1032 

  1033     case QNetworkAccessManager::DeleteOperation:

  1034         reply = manager.deleteResource(request);

  1035         break;

  1036 

  1037     default:

  1038         Q_ASSERT_X(false, "tst_QNetworkReply", "Invalid/unknown operation requested");

  1039     }

  1040     reply->setParent(this);

  1041     connect(reply, SIGNAL(finished()), SLOT(finished()));

  1042     connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), SLOT(gotError()));

  1043 

  1044     returnCode = Timeout;

  1045     loop = new QEventLoop;

  1046     QTimer::singleShot(20000, loop, SLOT(quit()));

  1047     int code = returnCode == Timeout ? loop->exec() : returnCode;

  1048     delete loop;

  1049     loop = 0;

  1050 

  1051     switch (code) {

  1052     case Failure:

  1053         return "Request failed: " + reply->errorString();

  1054     case Timeout:

  1055         return "Network timeout";

  1056     }

  1057     return QString();

  1058 }

  1059 

  1060 void tst_QNetworkReply::finished()

  1061 {

  1062     loop->exit(returnCode = Success);

  1063 }

  1064 

  1065 void tst_QNetworkReply::gotError()

  1066 {

  1067     loop->exit(returnCode = Failure);

  1068     disconnect(QObject::sender(), SIGNAL(finished()), this, 0);

  1069 }

  1070 

  1071 void tst_QNetworkReply::initTestCase()

  1072 {

  1073 #if !defined Q_OS_WIN

  1074     wronlyFileName = QDir::currentPath() + "/write-only";

  1075     QFile wr(wronlyFileName);

  1076     QVERIFY(wr.open(QIODevice::WriteOnly | QIODevice::Truncate));

  1077     wr.setPermissions(QFile::WriteOwner | QFile::WriteUser);

  1078     wr.close();

  1079 #endif

  1080 

  1081     QDir::setSearchPaths("srcdir", QStringList() << SRCDIR);

  1082 }

  1083 

  1084 void tst_QNetworkReply::cleanupTestCase()

  1085 {

  1086 #if !defined Q_OS_WIN

  1087     QFile::remove(wronlyFileName);

  1088 #endif

  1089 }

  1090 

  1091 void tst_QNetworkReply::init()

  1092 {

  1093     cleanup();

  1094 }

  1095 

  1096 void tst_QNetworkReply::cleanup()

  1097 {

  1098     QFile file(testFileName);

  1099     QVERIFY(!file.exists() || file.remove());

  1100 

  1101     // clear the internal cache

  1102     QNetworkAccessManagerPrivate::clearCache(&manager);

  1103     manager.setProxy(QNetworkProxy());

  1104 

  1105     // clear cookies

  1106     cookieJar->setAllCookies(QList<QNetworkCookie>());

  1107 }

  1108 

  1109 void tst_QNetworkReply::stateChecking()

  1110 {

  1111     QUrl url = QUrl("file:///");

  1112     QNetworkRequest req(url);   // you can't open this file, I know

  1113     QNetworkReplyPtr reply = manager.get(req);

  1114 

  1115     QVERIFY(reply.data());

  1116     QVERIFY(reply->isOpen());

  1117     QVERIFY(reply->isReadable());

  1118     QVERIFY(!reply->isWritable());

  1119     QCOMPARE(reply->errorString(), QString("Unknown error"));

  1120 

  1121     QCOMPARE(reply->manager(), &manager);

  1122     QCOMPARE(reply->request(), req);

  1123     QCOMPARE(int(reply->operation()), int(QNetworkAccessManager::GetOperation));

  1124     QCOMPARE(reply->error(), QNetworkReply::NoError);

  1125     QCOMPARE(reply->isFinished(), false);

  1126     QCOMPARE(reply->url(), url);

  1127 

  1128     reply->abort();

  1129 }

  1130 

  1131 void tst_QNetworkReply::invalidProtocol()

  1132 {

  1133     QUrl url = QUrl::fromEncoded("not-a-known-protocol://foo/bar");

  1134     QNetworkRequest req(url);