/****************************************************************************

**

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

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QtTest/QtTest>

#include <QtCore/QCryptographicHash>

#include <QtCore/QDataStream>

#include <QtCore/QUrl>

#include <QtCore/QEventLoop>

#include <QtCore/QFile>

#include <QtCore/QSharedPointer>

#include <QtCore/QTemporaryFile>

#include <QtNetwork/QTcpServer>

#include <QtNetwork/QTcpSocket>

#include <QtNetwork/QLocalSocket>

#include <QtNetwork/QLocalServer>

#include <QtNetwork/QHostInfo>

#include <QtNetwork/QFtp>

#include <QtNetwork/QAbstractNetworkCache>

#include <QtNetwork/qauthenticator.h>

#include <QtNetwork/qnetworkaccessmanager.h>

#include <QtNetwork/qnetworkrequest.h>

#include <QtNetwork/qnetworkreply.h>

#include <QtNetwork/qnetworkcookie.h>

#ifndef QT_NO_OPENSSL

#include <QtNetwork/qsslerror.h>

#include <QtNetwork/qsslconfiguration.h>

#endif

#include <time.h>

#include "private/qnetworkaccessmanager_p.h"

#ifdef Q_OS_SYMBIAN

#define SRCDIR "."

#endif

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

Q_DECLARE_METATYPE(QNetworkReply*)

Q_DECLARE_METATYPE(QAuthenticator*)

Q_DECLARE_METATYPE(QNetworkProxy)

Q_DECLARE_METATYPE(QNetworkProxyQuery)

Q_DECLARE_METATYPE(QList<QNetworkProxy>)

Q_DECLARE_METATYPE(QNetworkReply::NetworkError)

Q_DECLARE_METATYPE(QBuffer*)

class QNetworkReplyPtr: public QSharedPointer<QNetworkReply>

{

public:

    inline QNetworkReplyPtr(QNetworkReply *ptr = 0)

        : QSharedPointer<QNetworkReply>(ptr)

    { }

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

};

class MyCookieJar;

class tst_QNetworkReply: public QObject

{

    Q_OBJECT

    struct ProxyData {

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

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

        { }

        QByteArray tag;

        QNetworkProxy proxy;

        bool requiresAuthentication;

    };

    QEventLoop *loop;

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

    int returnCode;

    QString testFileName;

#if !defined Q_OS_WIN

    QString wronlyFileName;

#endif

    QString uniqueExtension;

    QList<ProxyData> proxies;

    QNetworkAccessManager manager;

    MyCookieJar *cookieJar;

#ifndef QT_NO_OPENSSL

    QSslConfiguration storedSslConfiguration;

    QList<QSslError> storedExpectedSslErrors;

#endif

public:

    tst_QNetworkReply();

    ~tst_QNetworkReply();

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

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

    QString runCustomRequest(const QNetworkRequest &request, QNetworkReplyPtr &reply,

                             const QByteArray &verb, QIODevice *data);

public Q_SLOTS:

    void finished();

    void gotError();

    void authenticationRequired(QNetworkReply*,QAuthenticator*);

    void proxyAuthenticationRequired(const QNetworkProxy &,QAuthenticator*);

#ifndef QT_NO_OPENSSL

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

    void storeSslConfiguration();

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

#endif

protected Q_SLOTS:

    void nestedEventLoops_slot();

private Q_SLOTS:

    void init();

    void cleanup();

    void initTestCase();

    void cleanupTestCase();

    void stateChecking();

    void invalidProtocol();

    void getFromData_data();

    void getFromData();

    void getFromFile();

    void getFromFileSpecial_data();

    void getFromFileSpecial();

    void getFromFtp_data();

    void getFromFtp();

    void getFromHttp_data();

    void getFromHttp();

    void getErrors_data();

    void getErrors();

    void putToFile_data();

    void putToFile();

    void putToFtp_data();

    void putToFtp();

    void putToHttp_data();

    void putToHttp();

    void postToHttp_data();

    void postToHttp();

    void deleteFromHttp_data();

    void deleteFromHttp();

    void putGetDeleteGetFromHttp_data();

    void putGetDeleteGetFromHttp();

    void sendCustomRequestToHttp_data();

    void sendCustomRequestToHttp();

    void ioGetFromData_data();

    void ioGetFromData();

    void ioGetFromFileSpecial_data();

    void ioGetFromFileSpecial();

    void ioGetFromFile_data();

    void ioGetFromFile();

    void ioGetFromFtp_data();

    void ioGetFromFtp();

    void ioGetFromFtpWithReuse();

    void ioGetFromHttp();

    void ioGetFromHttpWithReuseParallel();

    void ioGetFromHttpWithReuseSequential();

    void ioGetFromHttpWithAuth();

    void ioGetFromHttpWithProxyAuth();

    void ioGetFromHttpWithSocksProxy();

#ifndef QT_NO_OPENSSL

    void ioGetFromHttpsWithSslErrors();

    void ioGetFromHttpsWithIgnoreSslErrors();

    void ioGetFromHttpsWithSslHandshakeError();

#endif

    void ioGetFromHttpBrokenServer_data();

    void ioGetFromHttpBrokenServer();

    void ioGetFromHttpStatus100_data();

    void ioGetFromHttpStatus100();

    void ioGetFromHttpNoHeaders_data();

    void ioGetFromHttpNoHeaders();

    void ioGetFromHttpWithCache_data();

    void ioGetFromHttpWithCache();

    void ioGetWithManyProxies_data();

    void ioGetWithManyProxies();

    void ioPutToFileFromFile_data();

    void ioPutToFileFromFile();

    void ioPutToFileFromSocket_data();

    void ioPutToFileFromSocket();

    void ioPutToFileFromLocalSocket_data();

    void ioPutToFileFromLocalSocket();

    void ioPutToFileFromProcess_data();

    void ioPutToFileFromProcess();

    void ioPutToFtpFromFile_data();

    void ioPutToFtpFromFile();

    void ioPutToHttpFromFile_data();

    void ioPutToHttpFromFile();

    void ioPostToHttpFromFile_data();

    void ioPostToHttpFromFile();

    void ioPostToHttpFromSocket_data();

    void ioPostToHttpFromSocket();

    void ioPostToHttpFromMiddleOfFileToEnd();

    void ioPostToHttpFromMiddleOfFileFiveBytes();

    void ioPostToHttpFromMiddleOfQBufferFiveBytes();

    void ioPostToHttpNoBufferFlag();

    void ioPostToHttpUploadProgress();

    void ioPostToHttpEmptyUploadProgress();

    void lastModifiedHeaderForFile();

    void lastModifiedHeaderForHttp();

    void httpCanReadLine();

    void rateControl_data();

    void rateControl();

    void downloadProgress_data();

    void downloadProgress();

    void uploadProgress_data();

    void uploadProgress();

    void chaining_data();

    void chaining();

    void receiveCookiesFromHttp_data();

    void receiveCookiesFromHttp();

    void sendCookies_data();

    void sendCookies();

    void nestedEventLoops();

    void httpProxyCommands_data();

    void httpProxyCommands();

    void proxyChange();

    void authorizationError_data();

    void authorizationError();

    void httpConnectionCount();

    void httpReUsingConnectionSequential_data();

    void httpReUsingConnectionSequential();

    void httpReUsingConnectionFromFinishedSlot_data();

    void httpReUsingConnectionFromFinishedSlot();

    void httpRecursiveCreation();

#ifndef QT_NO_OPENSSL

    void ioPostToHttpsUploadProgress();

    void ignoreSslErrorsList_data();

    void ignoreSslErrorsList();

    void ignoreSslErrorsListWithSlot_data();

    void ignoreSslErrorsListWithSlot();

#endif

    void getAndThenDeleteObject_data();

    void getAndThenDeleteObject();

    void symbianOpenCDataUrlCrash();

    // NOTE: This test must be last!

    void parentingRepliesToTheApp();

};

QT_BEGIN_NAMESPACE

namespace QTest {

    template<>

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

    {

        const QMetaObject *mo = &QNetworkReply::staticMetaObject;

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

        if (index == -1)

            return qstrdup("");

        QMetaEnum qme = mo->enumerator(index);

        return qstrdup(qme.valueToKey(code));

    }

    template<>

    char *toString(const QNetworkCookie &cookie)

    {

        return qstrdup(cookie.toRawForm());

    }

    template<>

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

    {

        QString result = "QList(";

        bool first = true;

        foreach (QNetworkCookie cookie, list) {

            if (!first)

                result += ", ";

            first = false;

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

        }

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

    }

}

QT_END_NAMESPACE

#define RUN_REQUEST(call)                       \

    do {                                        \

        QString errorMsg = call;                \

        if (!errorMsg.isEmpty())                \

            QFAIL(qPrintable(errorMsg));        \

    } while (0);

// Does not work for POST/PUT!

class MiniHttpServer: public QTcpServer

{

    Q_OBJECT

public:

    QTcpSocket *client; // always the last one that was received

    QByteArray dataToTransmit;

    QByteArray receivedData;

    bool doClose;

    bool multiple;

    int totalConnections;

    MiniHttpServer(const QByteArray &data) : client(0), dataToTransmit(data), doClose(true), multiple(false), totalConnections(0)

    {

        listen();

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

    }

public slots:

    void doAccept()

    {

        client = nextPendingConnection();

        client->setParent(this);

        ++totalConnections;

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

    }

    void readyReadSlot()

    {

        receivedData += client->readAll();

        int doubleEndlPos = receivedData.indexOf("\r\n\r\n");

        if (doubleEndlPos != -1) {

            // multiple requests incoming. remove the bytes of the current one

            if (multiple)

                receivedData.remove(0, doubleEndlPos+4);

            client->write(dataToTransmit);

            if (doClose) {

                client->disconnectFromHost();

                disconnect(client, 0, this, 0);

                client = 0;

            }

        }

    }

};

class MyCookieJar: public QNetworkCookieJar

{

public:

    inline QList<QNetworkCookie> allCookies() const

        { return QNetworkCookieJar::allCookies(); }

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

        { QNetworkCookieJar::setAllCookies(cookieList); }

};

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;

    }

};

class MyMemoryCache: public QAbstractNetworkCache

{

public:

    typedef QPair<QNetworkCacheMetaData, QByteArray> CachedContent;

    typedef QHash<QByteArray, CachedContent> CacheData;

    CacheData cache;

    MyMemoryCache(QObject *parent) : QAbstractNetworkCache(parent) {}

    QNetworkCacheMetaData metaData(const QUrl &url)

    {

        return cache.value(url.toEncoded()).first;

    }

    void updateMetaData(const QNetworkCacheMetaData &metaData)

    {

        cache[metaData.url().toEncoded()].first = metaData;

    }

    QIODevice *data(const QUrl &url)

    {

        CacheData::ConstIterator it = cache.find(url.toEncoded());

        if (it == cache.constEnd())

            return 0;

        QBuffer *io = new QBuffer(this);

        io->setData(it->second);

        io->open(QIODevice::ReadOnly);

        io->seek(0);

        return io;

    }

    bool remove(const QUrl &url)

    {

        cache.remove(url.toEncoded());

        return true;

    }

    qint64 cacheSize() const

    {

        qint64 total = 0;

        foreach (const CachedContent &entry, cache)

            total += entry.second.size();

        return total;

    }

    QIODevice *prepare(const QNetworkCacheMetaData &)

    { Q_ASSERT(0 && "Should not have tried to add to the cache"); return 0; }

    void insert(QIODevice *)

    { Q_ASSERT(0 && "Should not have tried to add to the cache"); }

    void clear() { cache.clear(); }

};

Q_DECLARE_METATYPE(MyMemoryCache::CachedContent)

Q_DECLARE_METATYPE(MyMemoryCache::CacheData)

class DataReader: public QObject

{

    Q_OBJECT

public:

    qint64 totalBytes;

    QByteArray data;

    QIODevice *device;

    bool accumulate;

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

    {

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

    }

public slots:

    void doRead()

    {

        QByteArray buffer;

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

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

        if (bytesRead == -1) {

            QTestEventLoop::instance().exitLoop();

            return;

        }

        buffer.truncate(bytesRead);

        totalBytes += bytesRead;

        if (accumulate)

            data += buffer;

    }

};

class SocketPair: public QObject

{

    Q_OBJECT

public:

    QIODevice *endPoints[2];

    SocketPair(QObject *parent = 0)

        : QObject(parent)

    {

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