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

**

** Copyright (C) 2009 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/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)

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());

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 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 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 ioPostToHttpEmtpyUploadProgress();

    void rateControl_data();

    void rateControl();

    void downloadPerformance();

    void uploadPerformance();

    void performanceControlRate();

    void httpUploadPerformance();

    void httpDownloadPerformance_data();

    void httpDownloadPerformance();

    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();

#ifndef QT_NO_OPENSSL

    void ioPostToHttpsUploadProgress();

    void ignoreSslErrorsList_data();

    void ignoreSslErrorsList();

    void ignoreSslErrorsListWithSlot_data();

    void ignoreSslErrorsListWithSlot();

#endif

};

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);

class MiniHttpServer: public QTcpServer

{

    Q_OBJECT

    QTcpSocket *client;

public:

    QByteArray dataToTransmit;

    QByteArray receivedData;

    bool doClose;

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

    {

        listen();

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

    }

public slots:

    void doAccept()

    {

        client = nextPendingConnection();

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

    }

    void sendData()

    {

        receivedData += client->readAll();

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

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

            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 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 FixedSizeDataGenerator : public QIODevice

{

    Q_OBJECT

    enum { Idle, Started, Stopped } state;

public:

    FixedSizeDataGenerator(qint64 size) : state(Idle)

    { open(ReadOnly | Unbuffered);

      toBeGeneratedTotalCount = toBeGeneratedCount = size;

    }

    virtual qint64 bytesAvailable() const

    {

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

    }

    virtual bool isSequential() const{

        return false;

    }

    virtual bool reset() const{

        return false;

    }

    qint64 size() const {

        return toBeGeneratedTotalCount;

    }

public slots:

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

protected:

    virtual qint64 readData(char *data, qint64 maxlen)

    {

        memset(data, '@', maxlen);

        if (toBeGeneratedCount <= 0) {

            return -1;

        }

        qint64 n = qMin(maxlen, toBeGeneratedCount);

        toBeGeneratedCount -= n;

        if (toBeGeneratedCount <= 0) {

            // make sure this is a queued connection!

            emit readChannelFinished();

        }

        return n;

    }

    virtual qint64 writeData(const char *, qint64)

    { return -1; }

    qint64 toBeGeneratedCount;

    qint64 toBeGeneratedTotalCount;

};

class DataGenerator: public QIODevice

{

    Q_OBJECT

    enum { Idle, Started, Stopped } state;

public:

    DataGenerator() : state(Idle)

    { open(ReadOnly); }

    virtual bool isSequential() const { return true; }

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

public slots:

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

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

protected:

    virtual qint64 readData(char *data, qint64 maxlen)

    {

        if (state == Stopped)

            return -1;          // EOF

        // return as many bytes as are wanted

        memset(data, '@', maxlen);

        return maxlen;

    }

    virtual qint64 writeData(const char *, qint64)

    { return -1; }

};

class SocketPair: public QObject

{

    Q_OBJECT

public:

    QIODevice *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());

#ifndef Q_OS_SYMBIAN

        // need more time as working with embedded

		// device and testing from emualtor

		// things tend to get slower

        if (!active->waitForConnected(1000))

            return false;