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

**

** 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 <qcoreapplication.h>

#include <qfile.h>

#include <qbuffer.h>

#include "qftp.h"

#include <qmap.h>

#include <time.h>

#include <stdlib.h>

#include <QNetworkProxy>

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

//TESTED_CLASS=

//TESTED_FILES=

#ifdef Q_OS_SYMBIAN

// In Symbian OS test data is located in applications private dir

// Application private dir is default serach path for files, so SRCDIR can be set to empty

#define SRCDIR ""

#endif

class tst_QFtp : public QObject

{

    Q_OBJECT

public:

    tst_QFtp();

    virtual ~tst_QFtp();

public slots:

    void initTestCase_data();

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void connectToHost_data();

    void connectToHost();

    void connectToUnresponsiveHost();

    void login_data();

    void login();

    void close_data();

    void close();

    void list_data();

    void list();

    void cd_data();

    void cd();

    void get_data();

    void get();

    void put_data();

    void put();

    void remove();

    void mkdir_data();

    void mkdir();

    void mkdir2();

    void rmdir();

    void rename_data();

    void rename();

    void commandSequence_data();

    void commandSequence();

    void abort_data();

    void abort();

    void bytesAvailable_data();

    void bytesAvailable();

    void activeMode();

    void proxy_data();

    void proxy();

    void binaryAscii();

    void doneSignal();

    void queueMoreCommandsInDoneSlot();

protected slots:

    void stateChanged( int );

    void listInfo( const QUrlInfo & );

    void readyRead();

    void dataTransferProgress(qint64, qint64);

    void commandStarted( int );

    void commandFinished( int, bool );

    void done( bool );

    void activeModeDone( bool );

    void mkdir2Slot(int id, bool error);

    void cdUpSlot(bool);

private:

    QFtp *newFtp();

    void addCommand( QFtp::Command, int );

    bool fileExists( const QString &host, quint16 port, const QString &user, const QString &password, const QString &file, const QString &cdDir = QString::null );

    bool dirExists( const QString &host, quint16 port, const QString &user, const QString &password, const QString &cdDir, const QString &dirToCreate );

    void renameInit( const QString &host, const QString &user, const QString &password, const QString &createFile );

    void renameCleanup( const QString &host, const QString &user, const QString &password, const QString &fileToDelete );

    QFtp *ftp;

    QList<int> ids; // helper to make sure that all expected signals are emitted

    int current_id;

    int connectToHost_state;

    int close_state;

    int login_state;

    int cur_state;

    struct CommandResult

    {

        int id;

        int success;

    };

    QMap< QFtp::Command, CommandResult > resultMap;

    typedef QMap<QFtp::Command,CommandResult>::Iterator ResMapIt;

    int done_success;

    int commandSequence_success;

    qlonglong bytesAvailable_finishedGet;

    qlonglong bytesAvailable_finished;

    qlonglong bytesAvailable_done;

    QList<QUrlInfo> listInfo_i;

    QByteArray newData_ba;

    qlonglong bytesTotal;

    qlonglong bytesDone;

    bool inFileDirExistsFunction;

    QString uniqueExtension;

};

//#define DUMP_SIGNALS

const int bytesTotal_init = -10;

const int bytesDone_init = -10;

tst_QFtp::tst_QFtp()

{

    Q_SET_DEFAULT_IAP

}

tst_QFtp::~tst_QFtp()

{

}

void tst_QFtp::initTestCase_data()

{

    QTest::addColumn<bool>("setProxy");

    QTest::addColumn<int>("proxyType");

    QTest::newRow("WithoutProxy") << false << 0;

    QTest::newRow("WithSocks5Proxy") << true << int(QNetworkProxy::Socks5Proxy);

    //### doesn't work well yet.

    //QTest::newRow("WithHttpProxy") << true << int(QNetworkProxy::HttpProxy);

}

void tst_QFtp::initTestCase()

{

}

void tst_QFtp::cleanupTestCase()

{

}

void tst_QFtp::init()

{

    QFETCH_GLOBAL(bool, setProxy);

    if (setProxy) {

        QFETCH_GLOBAL(int, proxyType);

        if (proxyType == QNetworkProxy::Socks5Proxy) {

            QNetworkProxy::setApplicationProxy(QNetworkProxy(QNetworkProxy::Socks5Proxy, QtNetworkSettings::serverName(), 1080));

        } else if (proxyType == QNetworkProxy::HttpProxy) {

            QNetworkProxy::setApplicationProxy(QNetworkProxy(QNetworkProxy::HttpProxy, QtNetworkSettings::serverName(), 3128));

        }

    }

    ftp = 0;

    ids.clear();

    current_id = 0;

    resultMap.clear();

    connectToHost_state = -1;

    close_state = -1;

    login_state = -1;

    cur_state = QFtp::Unconnected;

    listInfo_i.clear();

    newData_ba = QByteArray();

    bytesTotal = bytesTotal_init;

    bytesDone = bytesDone_init;

    done_success = -1;

    commandSequence_success = -1;

    bytesAvailable_finishedGet = 1234567890;

    bytesAvailable_finished = 1234567890;

    bytesAvailable_done = 1234567890;

    inFileDirExistsFunction = FALSE;

#if !defined(Q_OS_WINCE)

    srand(time(0));

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

#else

    srand(0);

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

#endif

}

void tst_QFtp::cleanup()

{

    QFETCH_GLOBAL(bool, setProxy);

    if (setProxy) {

        QNetworkProxy::setApplicationProxy(QNetworkProxy::DefaultProxy);

    }

}

void tst_QFtp::connectToHost_data()

{

    QTest::addColumn<QString>("host");

    QTest::addColumn<uint>("port");

    QTest::addColumn<int>("state");

    QTest::newRow( "ok01" ) << QtNetworkSettings::serverName() << (uint)21 << (int)QFtp::Connected;

    QTest::newRow( "error01" ) << QtNetworkSettings::serverName() << (uint)2222 << (int)QFtp::Unconnected;

    QTest::newRow( "error02" ) << QString("foo.bar") << (uint)21 << (int)QFtp::Unconnected;

}

void tst_QFtp::connectToHost()

{

    QFETCH( QString, host );

    QFETCH( uint, port );

    ftp = newFtp();

    addCommand( QFtp::ConnectToHost, ftp->connectToHost( host, port ) );

    QTestEventLoop::instance().enterLoop( 61 );

    delete ftp;

    if ( QTestEventLoop::instance().timeout() )

        QFAIL( "Network operation timed out" );

    QTEST( connectToHost_state, "state" );

    ResMapIt it = resultMap.find( QFtp::ConnectToHost );

    QVERIFY( it != resultMap.end() );

    QFETCH( int, state );

    if ( state == QFtp::Connected ) {

        QVERIFY( it.value().success == 1 );

    } else {

        QVERIFY( it.value().success == 0 );

    }

}

void tst_QFtp::connectToUnresponsiveHost()

{

    QFETCH_GLOBAL(bool, setProxy);

    if (setProxy)

        QSKIP( "This test takes too long if we test with proxies too", SkipSingle );

    QString host = "1.2.3.4";

    uint port = 21;

    ftp = newFtp();

    addCommand( QFtp::ConnectToHost, ftp->connectToHost( host, port ) );

    qDebug( "About to connect to host that won't reply (this test takes 60 seconds)" );

    QTestEventLoop::instance().enterLoop( 61 );

#ifdef Q_OS_WIN

    /* On Windows, we do not get a timeout, because Winsock is behaving in a strange way:

    We issue two "WSAConnect()" calls, after the first, as a result we get WSAEWOULDBLOCK,

    after the second, we get WSAEISCONN, which means that the socket is connected, which cannot be.

    However, after some seconds we get a socket error saying that the remote host closed the connection,

    which can neither be. For this test, that would actually enable us to finish before timout, but handling that case

    (in void QFtpPI::error(QAbstractSocket::SocketError e)) breaks

    a lot of other stuff in QFtp, so we just expect this test to fail on Windows.

    */

    QEXPECT_FAIL("", "timeout not working due to strange Windows socket behaviour (see source file of this test for explanation)", Abort);

#endif

    QVERIFY2(! QTestEventLoop::instance().timeout(), "Network timeout longer than expected (should have been 60 seconds)");

    QVERIFY( ftp->state() == QFtp::Unconnected);

    ResMapIt it = resultMap.find( QFtp::ConnectToHost );

    QVERIFY( it != resultMap.end() );

    QVERIFY( it.value().success == 0 );

    delete ftp;

}

void tst_QFtp::login_data()

{

    QTest::addColumn<QString>("host");

    QTest::addColumn<uint>("port");

    QTest::addColumn<QString>("user");

    QTest::addColumn<QString>("password");

    QTest::addColumn<int>("success");

    QTest::newRow( "ok01" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString() << 1;

    QTest::newRow( "ok02" ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftp") << QString() << 1;

    QTest::newRow( "ok03" ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftp") << QString("foo") << 1;

    QTest::newRow( "ok04" ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest") << QString("password") << 1;

    QTest::newRow( "error01" ) << QtNetworkSettings::serverName() << (uint)21 << QString("foo") << QString() << 0;

    QTest::newRow( "error02" ) << QtNetworkSettings::serverName() << (uint)21 << QString("foo") << QString("bar") << 0;

}

void tst_QFtp::login()

{

    QFETCH( QString, host );

    QFETCH( uint, port );

    QFETCH( QString, user );

    QFETCH( QString, password );

    ftp = newFtp();

    addCommand( QFtp::ConnectToHost, ftp->connectToHost( host, port ) );

    addCommand( QFtp::Login, ftp->login( user, password ) );

    QTestEventLoop::instance().enterLoop( 30 );

    delete ftp;

    if ( QTestEventLoop::instance().timeout() )

        QFAIL( "Network operation timed out" );

    ResMapIt it = resultMap.find( QFtp::Login );

    QVERIFY( it != resultMap.end() );

    QTEST( it.value().success, "success" );

    if ( it.value().success ) {

        QVERIFY( login_state == QFtp::LoggedIn );

    } else {

        QVERIFY( login_state != QFtp::LoggedIn );

    }

}

void tst_QFtp::close_data()

{

    QTest::addColumn<QString>("host");

    QTest::addColumn<uint>("port");

    QTest::addColumn<QString>("user");

    QTest::addColumn<QString>("password");

    QTest::addColumn<bool>("login");

    QTest::newRow( "login01" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString() << (bool)TRUE;

    QTest::newRow( "login02" ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftp") << QString() << (bool)TRUE;

    QTest::newRow( "login03" ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftp") << QString("foo") << (bool)TRUE;

    QTest::newRow( "login04" ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest") << QString("password") << (bool)TRUE;

    QTest::newRow( "no-login01" ) << QtNetworkSettings::serverName() << (uint)21 << QString("") << QString("") << (bool)FALSE;

}

void tst_QFtp::close()

{

    QFETCH( QString, host );

    QFETCH( uint, port );

    QFETCH( QString, user );

    QFETCH( QString, password );

    QFETCH( bool, login );

    ftp = newFtp();

    addCommand( QFtp::ConnectToHost, ftp->connectToHost( host, port ) );

    if ( login )

        addCommand( QFtp::Login, ftp->login( user, password ) );

    addCommand( QFtp::Close, ftp->close() );

    QTestEventLoop::instance().enterLoop( 30 );

    delete ftp;

    if ( QTestEventLoop::instance().timeout() )

        QFAIL( "Network operation timed out" );

    QCOMPARE( close_state, (int)QFtp::Unconnected );

    ResMapIt it = resultMap.find( QFtp::Close );

    QVERIFY( it != resultMap.end() );

    QVERIFY( it.value().success == 1 );

}

void tst_QFtp::list_data()

{

    QTest::addColumn<QString>("host");

    QTest::addColumn<uint>("port");

    QTest::addColumn<QString>("user");

    QTest::addColumn<QString>("password");

    QTest::addColumn<QString>("dir");

    QTest::addColumn<int>("success");

    QTest::addColumn<QStringList>("entryNames"); // ### we should rather use a QList<QUrlInfo> here

    QStringList flukeRoot;

    flukeRoot << "pub";

    flukeRoot << "qtest";

    QStringList flukeQtest;

    flukeQtest << "bigfile";

    flukeQtest << "nonASCII";

    flukeQtest << "rfc3252";

    flukeQtest << "rfc3252.txt";

    flukeQtest << "upload";

    QTest::newRow( "workDir01" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString() << QString() << 1 << flukeRoot;

    QTest::newRow( "workDir02" ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest")     << QString("password")     << QString() << 1 << flukeRoot;

    QTest::newRow( "relPath01" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString() << QString("qtest") << 1 << flukeQtest;

    QTest::newRow( "relPath02" ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest")     << QString("password")     << QString("qtest") << 1 << flukeQtest;

    QTest::newRow( "absPath01" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString() << QString("/qtest") << 1 << flukeQtest;

    QTest::newRow( "absPath02" ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest")     << QString("password")     << QString("/var/ftp/qtest") << 1 << flukeQtest;

    QTest::newRow( "nonExist01" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString() << QString("foo")  << 1 << QStringList();

    QTest::newRow( "nonExist02" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString() << QString("/foo") << 1 << QStringList();

    // ### The microsoft server does not seem to work properly at the moment --

    // I am also not able to open a data connection with other, non-Qt FTP

    // clients to it.

    // QTest::newRow( "nonExist03" ) << "ftp.microsoft.com" << (uint)21 << QString() << QString() << QString("/foo") << 0 << QStringList();

    QStringList susePub;

    susePub << "README.mirror-policy" << "axp" << "i386" << "ia64" << "install" << "noarch" << "pubring.gpg-build.suse.de" << "update" << "x86_64";

    QTest::newRow( "epsvNotSupported" ) << QString("ftp.funet.fi") << (uint)21 << QString::fromLatin1("ftp") << QString::fromLatin1("root@") << QString("/pub/Linux/suse/suse") << 1 << susePub;

}

void tst_QFtp::list()

{

    QFETCH( QString, host );

    QFETCH( uint, port );

    QFETCH( QString, user );

    QFETCH( QString, password );

    QFETCH( QString, dir );

    ftp = newFtp();

    addCommand( QFtp::ConnectToHost, ftp->connectToHost( host, port ) );

    addCommand( QFtp::Login, ftp->login( user, password ) );

    addCommand( QFtp::List, ftp->list( dir ) );

    addCommand( QFtp::Close, ftp->close() );

    QTestEventLoop::instance().enterLoop( 30 );

    delete ftp;

    if ( QTestEventLoop::instance().timeout() )

        QFAIL( "Network operation timed out" );

    ResMapIt it = resultMap.find( QFtp::List );

    QVERIFY( it != resultMap.end() );

    QTEST( it.value().success, "success" );

    QFETCH( QStringList, entryNames );

    QCOMPARE( listInfo_i.count(), entryNames.count() );

    for ( uint i=0; i < (uint) entryNames.count(); i++ ) {

        QCOMPARE( listInfo_i[i].name(), entryNames[i] );

    }

}

void tst_QFtp::cd_data()

{

    QTest::addColumn<QString>("host");

    QTest::addColumn<uint>("port");

    QTest::addColumn<QString>("user");

    QTest::addColumn<QString>("password");

    QTest::addColumn<QString>("dir");

    QTest::addColumn<int>("success");

    QTest::addColumn<QStringList>("entryNames"); // ### we should rather use a QList<QUrlInfo> here

    QStringList flukeRoot;

    flukeRoot << "qtest";

    QStringList flukeQtest;

    flukeQtest << "bigfile";

    flukeQtest << "nonASCII";

    flukeQtest << "rfc3252";

    flukeQtest << "rfc3252.txt";

    flukeQtest << "upload";

    QTest::newRow( "relPath01" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString() << QString("qtest") << 1 << flukeQtest;

    QTest::newRow( "relPath02" ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest")     << QString("password")     << QString("qtest") << 1 << flukeQtest;

    QTest::newRow( "absPath01" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString() << QString("/qtest") << 1 << flukeQtest;

    QTest::newRow( "absPath02" ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest")     << QString("password")     << QString("/var/ftp/qtest") << 1 << flukeQtest;

    QTest::newRow( "nonExist01" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString() << QString("foo")  << 0 << QStringList();

    QTest::newRow( "nonExist03" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString() << QString("/foo") << 0 << QStringList();

}

void tst_QFtp::cd()

{

    QFETCH( QString, host );

    QFETCH( uint, port );