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

     2 **

     3 ** Copyright (C) 2010 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 

    45 #include <qcoreapplication.h>

    46 #include <qfile.h>

    47 #include <qbuffer.h>

    48 #include "qftp.h"

    49 #include <qmap.h>

    50 #include <time.h>

    51 #include <stdlib.h>

    52 #include <QNetworkProxy>

    53 

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

    55 

    56 //TESTED_CLASS=

    57 //TESTED_FILES=

    58 

    59 #ifdef Q_OS_SYMBIAN

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

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

    62 #define SRCDIR ""

    63 #endif

    64 

    65 

    66 

    67 class tst_QFtp : public QObject

    68 {

    69     Q_OBJECT

    70 

    71 public:

    72     tst_QFtp();

    73     virtual ~tst_QFtp();

    74 

    75 

    76 public slots:

    77     void initTestCase_data();

    78     void initTestCase();

    79     void cleanupTestCase();

    80     void init();

    81     void cleanup();

    82 private slots:

    83     void connectToHost_data();

    84     void connectToHost();

    85     void connectToUnresponsiveHost();

    86     void login_data();

    87     void login();

    88     void close_data();

    89     void close();

    90 

    91     void list_data();

    92     void list();

    93     void cd_data();

    94     void cd();

    95     void get_data();

    96     void get();

    97     void put_data();

    98     void put();

    99     void remove();

   100     void mkdir_data();

   101     void mkdir();

   102     void mkdir2();

   103     void rmdir();

   104     void rename_data();

   105     void rename();

   106 

   107     void commandSequence_data();

   108     void commandSequence();

   109 

   110     void abort_data();

   111     void abort();

   112 

   113     void bytesAvailable_data();

   114     void bytesAvailable();

   115 

   116     void activeMode();

   117 

   118     void proxy_data();

   119     void proxy();

   120 

   121     void binaryAscii();

   122 

   123     void doneSignal();

   124     void queueMoreCommandsInDoneSlot();

   125 

   126 protected slots:

   127     void stateChanged( int );

   128     void listInfo( const QUrlInfo & );

   129     void readyRead();

   130     void dataTransferProgress(qint64, qint64);

   131 

   132     void commandStarted( int );

   133     void commandFinished( int, bool );

   134     void done( bool );

   135     void activeModeDone( bool );

   136     void mkdir2Slot(int id, bool error);

   137     void cdUpSlot(bool);

   138 

   139 private:

   140     QFtp *newFtp();

   141     void addCommand( QFtp::Command, int );

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

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

   144 

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

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

   147 

   148     QFtp *ftp;

   149 

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

   151     int current_id;

   152 

   153     int connectToHost_state;

   154     int close_state;

   155     int login_state;

   156     int cur_state;

   157     struct CommandResult

   158     {

   159         int id;

   160         int success;

   161     };

   162     QMap< QFtp::Command, CommandResult > resultMap;

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

   164 

   165     int done_success;

   166     int commandSequence_success;

   167 

   168     qlonglong bytesAvailable_finishedGet;

   169     qlonglong bytesAvailable_finished;

   170     qlonglong bytesAvailable_done;

   171 

   172     QList<QUrlInfo> listInfo_i;

   173     QByteArray newData_ba;

   174     qlonglong bytesTotal;

   175     qlonglong bytesDone;

   176 

   177     bool inFileDirExistsFunction;

   178 

   179     QString uniqueExtension;

   180 };

   181 

   182 //#define DUMP_SIGNALS

   183 

   184 const int bytesTotal_init = -10;

   185 const int bytesDone_init = -10;

   186 

   187 tst_QFtp::tst_QFtp()

   188 {

   189     Q_SET_DEFAULT_IAP

   190 }

   191 

   192 tst_QFtp::~tst_QFtp()

   193 {

   194 }

   195 

   196 void tst_QFtp::initTestCase_data()

   197 {

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

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

   200 

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

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

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

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

   205 }

   206 

   207 void tst_QFtp::initTestCase()

   208 {

   209 }

   210 

   211 void tst_QFtp::cleanupTestCase()

   212 {

   213 }

   214 

   215 void tst_QFtp::init()

   216 {

   217     QFETCH_GLOBAL(bool, setProxy);

   218     if (setProxy) {

   219         QFETCH_GLOBAL(int, proxyType);

   220         if (proxyType == QNetworkProxy::Socks5Proxy) {

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

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

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

   224         }

   225     }

   226 

   227     ftp = 0;

   228 

   229     ids.clear();

   230     current_id = 0;

   231 

   232     resultMap.clear();

   233     connectToHost_state = -1;

   234     close_state = -1;

   235     login_state = -1;

   236     cur_state = QFtp::Unconnected;

   237 

   238     listInfo_i.clear();

   239     newData_ba = QByteArray();

   240     bytesTotal = bytesTotal_init;

   241     bytesDone = bytesDone_init;

   242 

   243     done_success = -1;

   244     commandSequence_success = -1;

   245 

   246     bytesAvailable_finishedGet = 1234567890;

   247     bytesAvailable_finished = 1234567890;

   248     bytesAvailable_done = 1234567890;

   249 

   250     inFileDirExistsFunction = FALSE;

   251 

   252 #if !defined(Q_OS_WINCE)

   253     srand(time(0));

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

   255 #else

   256     srand(0);

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

   258 #endif

   259 }

   260 

   261 void tst_QFtp::cleanup()

   262 {

   263     QFETCH_GLOBAL(bool, setProxy);

   264     if (setProxy) {

   265         QNetworkProxy::setApplicationProxy(QNetworkProxy::DefaultProxy);

   266     }

   267 }

   268 

   269 void tst_QFtp::connectToHost_data()

   270 {

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

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

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

   274 

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

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

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

   278 }

   279 

   280 void tst_QFtp::connectToHost()

   281 {

   282     QFETCH( QString, host );

   283     QFETCH( uint, port );

   284 

   285     ftp = newFtp();

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

   287 

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

   289     delete ftp;

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

   291         QFAIL( "Network operation timed out" );

   292 

   293     QTEST( connectToHost_state, "state" );

   294 

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

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

   297     QFETCH( int, state );

   298     if ( state == QFtp::Connected ) {

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

   300     } else {

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

   302     }

   303 }

   304 

   305 void tst_QFtp::connectToUnresponsiveHost()

   306 {

   307     QFETCH_GLOBAL(bool, setProxy);

   308     if (setProxy)

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

   310 

   311     QString host = "192.0.2.42"; // IP out of TEST-NET, should be unreachable

   312     uint port = 21;

   313 

   314     ftp = newFtp();

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

   316 

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

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

   319 #ifdef Q_OS_WIN

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

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

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

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

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

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

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

   327     */

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

   329 #endif

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

   331 

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

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

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

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

   336 

   337     delete ftp;

   338 }

   339 

   340 void tst_QFtp::login_data()

   341 {

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

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

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

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

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

   347 

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

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

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

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

   352 

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

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

   355 }

   356 

   357 void tst_QFtp::login()

   358 {

   359     QFETCH( QString, host );

   360     QFETCH( uint, port );

   361     QFETCH( QString, user );

   362     QFETCH( QString, password );

   363 

   364     ftp = newFtp();

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

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

   367 

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

   369     delete ftp;

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

   371         QFAIL( "Network operation timed out" );

   372 

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

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

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

   376 

   377     if ( it.value().success ) {

   378         QVERIFY( login_state == QFtp::LoggedIn );

   379     } else {

   380         QVERIFY( login_state != QFtp::LoggedIn );

   381     }

   382 }

   383 

   384 void tst_QFtp::close_data()

   385 {

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

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

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

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

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

   391 

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

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

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

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

   396 

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

   398 }

   399 

   400 void tst_QFtp::close()

   401 {

   402     QFETCH( QString, host );

   403     QFETCH( uint, port );

   404     QFETCH( QString, user );

   405     QFETCH( QString, password );

   406     QFETCH( bool, login );

   407 

   408     ftp = newFtp();

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

   410     if ( login )

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

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

   413 

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

   415     delete ftp;

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

   417         QFAIL( "Network operation timed out" );

   418 

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

   420 

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

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

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

   424 }

   425 

   426 void tst_QFtp::list_data()

   427 {

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

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

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

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

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

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

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

   435 

   436     QStringList flukeRoot;

   437     flukeRoot << "pub";

   438     flukeRoot << "qtest";

   439     QStringList flukeQtest;

   440     flukeQtest << "bigfile";

   441     flukeQtest << "nonASCII";

   442     flukeQtest << "rfc3252";

   443     flukeQtest << "rfc3252.txt";

   444     flukeQtest << "upload";

   445 

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

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

   448 

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

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

   451 

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

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

   454 

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

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

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

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

   459     // clients to it.

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

   461 

   462     QStringList susePub;

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

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

   465 }

   466 

   467 void tst_QFtp::list()

   468 {

   469     QFETCH( QString, host );

   470     QFETCH( uint, port );

   471     QFETCH( QString, user );

   472     QFETCH( QString, password );

   473     QFETCH( QString, dir );

   474 

   475     ftp = newFtp();

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

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

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

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

   480 

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

   482     delete ftp;

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

   484         QFAIL( "Network operation timed out" );

   485 

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

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

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

   489     QFETCH( QStringList, entryNames );

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

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

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

   493     }

   494 }

   495 

   496 void tst_QFtp::cd_data()

   497 {

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

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

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

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

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

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

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

   505 

   506     QStringList flukeRoot;

   507     flukeRoot << "qtest";

   508     QStringList flukeQtest;

   509     flukeQtest << "bigfile";

   510     flukeQtest << "nonASCII";

   511     flukeQtest << "rfc3252";

   512     flukeQtest << "rfc3252.txt";

   513     flukeQtest << "upload";

   514 

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

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

   517 

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

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

   520 

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

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

   523 }

   524 

   525 void tst_QFtp::cd()

   526 {

   527     QFETCH( QString, host );

   528     QFETCH( uint, port );

   529     QFETCH( QString, user );

   530     QFETCH( QString, password );

   531     QFETCH( QString, dir );

   532 

   533     ftp = newFtp();

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

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

   536     addCommand( QFtp::Cd, ftp->cd( dir ) );

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

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

   539 

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

   541 

   542     delete ftp;

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

   544         QFAIL( "Network operation timed out" );

   545     }

   546 

   547     ResMapIt it = resultMap.find( QFtp::Cd );

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

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

   550     QFETCH( QStringList, entryNames );

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

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

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

   554     }

   555 }

   556 

   557 void tst_QFtp::get_data()

   558 {

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

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

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

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

   563     QTest::addColumn<QString>("file");

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

   565     QTest::addColumn<QByteArray>("res");

   566     QTest::addColumn<bool>("useIODevice");

   567 

   568     // ### move this into external testdata

   569     QFile file( SRCDIR "rfc3252.txt" );

   570     QVERIFY( file.open( QIODevice::ReadOnly ) );

   571     QByteArray rfc3252 = file.readAll();

   572 

   573     // test the two get() overloads in one routine

   574     for ( int i=0; i<2; i++ ) {

   575         QTest::newRow( QString("relPath01_%1").arg(i).toLatin1().constData() ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString()

   576                 << "qtest/rfc3252" << 1 << rfc3252 << (bool)(i==1);

   577         QTest::newRow( QString("relPath02_%1").arg(i).toLatin1().constData() ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest")     << QString("password")

   578                 << "qtest/rfc3252" << 1 << rfc3252 << (bool)(i==1);

   579 

   580         QTest::newRow( QString("absPath01_%1").arg(i).toLatin1().constData() ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString()

   581                 << "/qtest/rfc3252" << 1 << rfc3252 << (bool)(i==1);

   582         QTest::newRow( QString("absPath02_%1").arg(i).toLatin1().constData() ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest")     << QString("password")

   583                 << "/var/ftp/qtest/rfc3252" << 1 << rfc3252 << (bool)(i==1);

   584 

   585         QTest::newRow( QString("nonExist01_%1").arg(i).toLatin1().constData() ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString()

   586                 << QString("foo")  << 0 << QByteArray() << (bool)(i==1);

   587         QTest::newRow( QString("nonExist02_%1").arg(i).toLatin1().constData() ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString()

   588                 << QString("/foo") << 0 << QByteArray() << (bool)(i==1);

   589     }

   590 }

   591 

   592 void tst_QFtp::get()

   593 {

   594     // for the overload that takes a QIODevice

   595     QByteArray buf_ba;

   596     QBuffer buf( &buf_ba );

   597 

   598     QFETCH( QString, host );

   599     QFETCH( uint, port );

   600     QFETCH( QString, user );

   601     QFETCH( QString, password );

   602     QFETCH( QString, file );

   603     QFETCH( bool, useIODevice );

   604 

   605     ftp = newFtp();

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

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

   608     if ( useIODevice ) {

   609         buf.open( QIODevice::WriteOnly );

   610         addCommand( QFtp::Get, ftp->get( file, &buf ) );

   611     } else {

   612         addCommand( QFtp::Get, ftp->get( file ) );

   613     }

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

   615 

   616     QTestEventLoop::instance().enterLoop( 50 );

   617     delete ftp;

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

   619         QFAIL( "Network operation timed out" );

   620 

   621     ResMapIt it = resultMap.find( QFtp::Get );

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

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

   624     if ( useIODevice ) {

   625         QTEST( buf_ba, "res" );

   626     } else {

   627         QTEST( newData_ba, "res" );

   628     }

   629     QVERIFY( bytesTotal != bytesTotal_init );

   630     if ( bytesTotal != -1 ) {

   631         QVERIFY( bytesDone == bytesTotal );

   632     }

   633     if ( useIODevice ) {

   634         if ( bytesDone != bytesDone_init ) {

   635             QVERIFY( (int)buf_ba.size() == bytesDone );

   636         }

   637     } else {

   638         if ( bytesDone != bytesDone_init ) {

   639             QVERIFY( (int)newData_ba.size() == bytesDone );

   640         }

   641     }

   642 }

   643 

   644 void tst_QFtp::put_data()

   645 {

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

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

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

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

   650     QTest::addColumn<QString>("file");

   651     QTest::addColumn<QByteArray>("fileData");

   652     QTest::addColumn<bool>("useIODevice");

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

   654 

   655     // ### move this into external testdata

   656     QFile file( SRCDIR "rfc3252.txt" );

   657     QVERIFY( file.open( QIODevice::ReadOnly ) );

   658     QByteArray rfc3252 = file.readAll();

   659 

   660     QByteArray bigData( 10*1024*1024, 0 );

   661     bigData.fill( 'A' );

   662 

   663     // test the two put() overloads in one routine

   664     for ( int i=0; i<2; i++ ) {

   665         QTest::newRow( QString("relPath01_%1").arg(i).toLatin1().constData() ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString()

   666                 << QString("qtest/upload/rel01_%1") << rfc3252

   667                 << (bool)(i==1) << 1;

   668         /*

   669     QTest::newRow( QString("relPath02_%1").arg(i).toLatin1().constData() ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest")     << QString("password")

   670         << QString("qtest/upload/rel02_%1") << rfc3252

   671         << (bool)(i==1) << 1;

   672     QTest::newRow( QString("relPath03_%1").arg(i).toLatin1().constData() ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest")     << QString("password")

   673         << QString("qtest/upload/rel03_%1") << QByteArray()

   674         << (bool)(i==1) << 1;

   675     QTest::newRow( QString("relPath04_%1").arg(i).toLatin1().constData() ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest")     << QString("password")

   676         << QString("qtest/upload/rel04_%1") << bigData

   677         << (bool)(i==1) << 1;

   678 

   679     QTest::newRow( QString("absPath01_%1").arg(i).toLatin1().constData() ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString()

   680         << QString("/qtest/upload/abs01_%1") << rfc3252

   681         << (bool)(i==1) << 1;

   682     QTest::newRow( QString("absPath02_%1").arg(i).toLatin1().constData() ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest")     << QString("password")

   683         << QString("/srv/ftp/qtest/upload/abs02_%1") << rfc3252

   684         << (bool)(i==1) << 1;

   685 

   686     QTest::newRow( QString("nonExist01_%1").arg(i).toLatin1().constData() ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString()

   687         << QString("foo")  << QByteArray()

   688         << (bool)(i==1) << 0;

   689     QTest::newRow( QString("nonExist02_%1").arg(i).toLatin1().constData() ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString()

   690         << QString("/foo") << QByteArray()

   691         << (bool)(i==1) << 0;

   692 */

   693     }

   694 }

   695 

   696 void tst_QFtp::put()

   697 {

   698     QFETCH( QString, host );

   699     QFETCH( uint, port );

   700     QFETCH( QString, user );

   701     QFETCH( QString, password );

   702     QFETCH( QString, file );

   703     QFETCH( QByteArray, fileData );

   704     QFETCH( bool, useIODevice );

   705 

   706 #ifdef Q_OS_WIN

   707     QFETCH_GLOBAL(bool, setProxy);

   708     if (setProxy) {

   709         QFETCH_GLOBAL(int, proxyType);

   710         if (proxyType == QNetworkProxy::Socks5Proxy) {

   711             QSKIP("With socks5 the put() test takes too long time on Windows.", SkipAll);

   712         }

   713     }

   714 #endif

   715 

   716     const int timestep = 50;

   717 

   718     if(file.contains('%'))

   719         file = file.arg(uniqueExtension);

   720 

   721     // for the overload that takes a QIODevice

   722     QBuffer buf_fileData( &fileData );

   723     buf_fileData.open( QIODevice::ReadOnly );

   724 

   725     ResMapIt it;

   726     //////////////////////////////////////////////////////////////////

   727     // upload the file

   728     init();

   729     ftp = newFtp();

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

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

   732     if ( useIODevice )

   733         addCommand( QFtp::Put, ftp->put( &buf_fileData, file ) );

   734     else

   735         addCommand( QFtp::Put, ftp->put( fileData, file ) );

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

   737 

   738     for(int time = 0; time <= fileData.length() / 20000; time += timestep) {

   739         QTestEventLoop::instance().enterLoop( timestep );

   740         if(ftp->currentCommand() == QFtp::None)

   741             break;

   742     }

   743     delete ftp;

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

   745         QFAIL( "Network operation timed out" );

   746 

   747     it = resultMap.find( QFtp::Put );

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

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

   750     if ( !it.value().success ) {

   751         QVERIFY( !fileExists( host, port, user, password, file ) );

   752         return; // the following tests are only meaningful if the file could be put

   753     }

   754     QVERIFY( bytesTotal == (int)fileData.size() );

   755     QVERIFY( bytesDone == bytesTotal );

   756 

   757     QVERIFY( fileExists( host, port, user, password, file ) );

   758 

   759     //////////////////////////////////////////////////////////////////

   760     // fetch file to make sure that it is equal to the uploaded file

   761     init();

   762     ftp = newFtp();

   763     QBuffer buf;

   764     buf.open( QIODevice::WriteOnly );

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

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

   767     addCommand( QFtp::Get, ftp->get( file, &buf ) );

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

   769 

   770     for(int time = 0; time <= fileData.length() / 20000; time += timestep) {

   771         QTestEventLoop::instance().enterLoop( timestep );

   772         if(ftp->currentCommand() == QFtp::None)

   773             break;

   774     }

   775     delete ftp;

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

   777         QFAIL( "Network operation timed out" );

   778 

   779     QVERIFY( done_success == 1 );

   780     QTEST( buf.buffer(), "fileData" );

   781 

   782     //////////////////////////////////////////////////////////////////

   783     // cleanup (i.e. remove the file) -- this also tests the remove command

   784     init();

   785     ftp = newFtp();

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

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

   788     addCommand( QFtp::Remove, ftp->remove( file ) );

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

   790 

   791     QTestEventLoop::instance().enterLoop( timestep );

   792     delete ftp;

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

   794         QFAIL( "Network operation timed out" );

   795 

   796     it = resultMap.find( QFtp::Remove );

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

   798     QCOMPARE( it.value().success, 1 );

   799 

   800     QVERIFY( !fileExists( host, port, user, password, file ) );

   801 }

   802 

   803 void tst_QFtp::remove()

   804 {

   805     DEPENDS_ON( "put" );

   806 }

   807 

   808 void tst_QFtp::mkdir_data()

   809 {

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

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

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

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

   814     QTest::addColumn<QString>("cdDir");

   815     QTest::addColumn<QString>("dirToCreate");

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

   817 

   818     QTest::newRow( "relPath01" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString()

   819             << "qtest/upload" << QString("rel01_%1") << 1;

   820     QTest::newRow( "relPath02" ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest")     << QString("password")

   821             << "qtest/upload" << QString("rel02_%1") << 1;

   822     QTest::newRow( "relPath03" ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest")     << QString("password")

   823             << "qtest/upload" << QString("rel03_%1") << 1;

   824 

   825     QTest::newRow( "absPath01" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString()

   826             << "." << QString("/qtest/upload/abs01_%1") << 1;

   827     QTest::newRow( "absPath02" ) << QtNetworkSettings::serverName() << (uint)21 << QString("ftptest")     << QString("password")

   828             << "." << QString("/var/ftp/qtest/upload/abs02_%1") << 1;

   829 

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

   831     QTest::newRow( "nonExist01" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString()

   832             << "." << QString("foo")  << 0;

   833     QTest::newRow( "nonExist02" ) << QtNetworkSettings::serverName() << (uint)21 << QString() << QString()

   834             << "." << QString("/foo") << 0;

   835 }

   836 

   837 void tst_QFtp::mkdir()

   838 {

   839     QFETCH( QString, host );

   840     QFETCH( uint, port );

   841     QFETCH( QString, user );

   842     QFETCH( QString, password );

   843     QFETCH( QString, cdDir );

   844     QFETCH( QString, dirToCreate );

   845 

   846     if(dirToCreate.contains('%'))

   847         dirToCreate = dirToCreate.arg(uniqueExtension);

   848 

   849     //////////////////////////////////////////////////////////////////

   850     // create the directory

   851     init();

   852     ftp = newFtp();

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

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

   855     addCommand( QFtp::Cd, ftp->cd( cdDir ) );

   856     addCommand( QFtp::Mkdir, ftp->mkdir( dirToCreate ) );

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

   858 

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

   860     delete ftp;

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

   862         QFAIL( "Network operation timed out" );

   863 

   864     ResMapIt it = resultMap.find( QFtp::Mkdir );

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

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

   867     if ( !it.value().success ) {

   868         QVERIFY( !dirExists( host, port, user, password, cdDir, dirToCreate ) );

   869         return; // the following tests are only meaningful if the dir could be created

   870     }

   871     QVERIFY( dirExists( host, port, user, password, cdDir, dirToCreate ) );

   872 

   873     //////////////////////////////////////////////////////////////////

   874     // create the directory again (should always fail!)

   875     init();

   876     ftp = newFtp();

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

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

   879     addCommand( QFtp::Cd, ftp->cd( cdDir ) );

   880     addCommand( QFtp::Mkdir, ftp->mkdir( dirToCreate ) );

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

   882 

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

   884     delete ftp;

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

   886         QFAIL( "Network operation timed out" );

   887 

   888     it = resultMap.find( QFtp::Mkdir );

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

   890     QCOMPARE( it.value().success, 0 );

   891 

   892     //////////////////////////////////////////////////////////////////

   893     // remove the directory

   894     init();

   895     ftp = newFtp();

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

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

   898     addCommand( QFtp::Cd, ftp->cd( cdDir ) );

   899     addCommand( QFtp::Rmdir, ftp->rmdir( dirToCreate ) );

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

   901 

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

   903     delete ftp;

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

   905         QFAIL( "Network operation timed out" );

   906 

   907     it = resultMap.find( QFtp::Rmdir );

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

   909     QCOMPARE( it.value().success, 1 );

   910 

   911     QVERIFY( !dirExists( host, port, user, password, cdDir, dirToCreate ) );

   912 }

   913 

   914 void tst_QFtp::mkdir2()

   915 {

   916     ftp = new QFtp;

   917     ftp->connectToHost(QtNetworkSettings::serverName());

   918     ftp->login();

   919     current_id = ftp->cd("kake/test");

   920 

   921     QEventLoop loop;

   922     connect(ftp, SIGNAL(done(bool)), &loop, SLOT(quit()));

   923     connect(ftp, SIGNAL(commandFinished(int, bool)), this, SLOT(mkdir2Slot(int, bool)));

   924     QTimer::singleShot(5000, &loop, SLOT(quit()));

   925 

   926     QSignalSpy commandStartedSpy(ftp, SIGNAL(commandStarted(int)));

   927     QSignalSpy commandFinishedSpy(ftp, SIGNAL(commandFinished(int, bool)));

   928 

   929     loop.exec();

   930 

   931     QCOMPARE(commandStartedSpy.count(), 4); // connect, login, cd, mkdir

   932     QCOMPARE(commandFinishedSpy.count(), 4);

   933 

   934     for (int i = 0; i < 4; ++i)

   935         QCOMPARE(commandFinishedSpy.at(i).at(0), commandStartedSpy.at(i).at(0));

   936 

   937     QVERIFY(!commandFinishedSpy.at(0).at(1).toBool());

   938     QVERIFY(!commandFinishedSpy.at(1).at(1).toBool());

   939     QVERIFY(commandFinishedSpy.at(2).at(1).toBool());

   940     QVERIFY(commandFinishedSpy.at(3).at(1).toBool());

   941 

   942     delete ftp;

   943 }

   944 

   945 void tst_QFtp::mkdir2Slot(int id, bool)

   946 {

   947     if (id == current_id)

   948         ftp->mkdir("kake/test");

   949 }

   950 

   951 void tst_QFtp::rmdir()

   952 {

   953     DEPENDS_ON( "mkdir" );

   954 }

   955 

   956 void tst_QFtp::rename_data()

   957 {

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

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

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

   961     QTest::addColumn<QString>("cdDir");

   962     QTest::addColumn<QString>("oldfile");

   963     QTest::addColumn<QString>("newfile");

   964     QTest::addColumn<QString>("createFile");

   965     QTest::addColumn<QString>("renamedFile");

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

   967 

   968     QTest::newRow("relPath01") << QtNetworkSettings::serverName() << QString() << QString()

   969             << "qtest/upload"

   970             << QString("rel_old01_%1") << QString("rel_new01_%1")

   971             << QString("qtest/upload/rel_old01_%1") << QString("qtest/upload/rel_new01_%1")

   972             << 1;

   973     QTest::newRow("relPath02") << QtNetworkSettings::serverName() << QString("ftptest")     << "password"

   974             << "qtest/upload"

   975             << QString("rel_old02_%1") << QString("rel_new02_%1")

   976             << QString("qtest/upload/rel_old02_%1") << QString("qtest/upload/rel_new02_%1")

   977             << 1;

   978     QTest::newRow("relPath03") << QtNetworkSettings::serverName() << QString("ftptest")     << "password"

   979             << "qtest/upload"

   980             << QString("rel_old03_%1")<< QString("rel_new03_%1")

   981             << QString("qtest/upload/rel_old03_%1") << QString("qtest/upload/rel_new03_%1")

   982             << 1;

   983 

   984     QTest::newRow("absPath01") << QtNetworkSettings::serverName() << QString() << QString()

   985             << QString()

   986             << QString("/qtest/upload/abs_old01_%1") << QString("/qtest/upload/abs_new01_%1")

   987             << QString("/qtest/upload/abs_old01_%1") << QString("/qtest/upload/abs_new01_%1")

   988             << 1;

   989     QTest::newRow("absPath02") << QtNetworkSettings::serverName() << QString("ftptest")     << "password"

   990             << QString()

   991             << QString("/var/ftp/qtest/upload/abs_old02_%1") << QString("/var/ftp/qtest/upload/abs_new02_%1")

   992             << QString("/var/ftp/qtest/upload/abs_old02_%1") << QString("/var/ftp/qtest/upload/abs_new02_%1")

   993             << 1;

   994 

   995     QTest::newRow("nonExist01") << QtNetworkSettings::serverName() << QString() << QString()

   996             << QString()

   997             << QString("foo") << "new_foo"

   998             << QString() << QString()

   999             << 0;

  1000     QTest::newRow("nonExist02") << QtNetworkSettings::serverName() << QString() << QString()

  1001             << QString()

  1002             << QString("/foo") << QString("/new_foo")

  1003             << QString() << QString()

  1004             << 0;

  1005 }

  1006 

  1007 void tst_QFtp::renameInit( const QString &host, const QString &user, const QString &password, const QString &createFile )

  1008 {

  1009     if ( !createFile.isNull() ) {

  1010         // upload the file

  1011         init();

  1012         ftp = newFtp();

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

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

  1015         addCommand( QFtp::Put, ftp->put( QByteArray(), createFile ) );

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

  1017 

  1018         QTestEventLoop::instance().enterLoop( 50 );

  1019         delete ftp;

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

  1021             QFAIL( "Network operation timed out" );

  1022 

  1023         ResMapIt it = resultMap.find( QFtp::Put );

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

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

  1026 

  1027         QVERIFY( fileExists( host, 21, user, password, createFile ) );

  1028     }

  1029 }

  1030 

  1031 void tst_QFtp::renameCleanup( const QString &host, const QString &user, const QString &password, const QString &fileToDelete )

  1032 {

  1033     if ( !fileToDelete.isNull() ) {

  1034         // cleanup (i.e. remove the file)

  1035         init();

  1036         ftp = newFtp();

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

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

  1039         addCommand( QFtp::Remove, ftp->remove( fileToDelete ) );

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

  1041 

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

  1043         delete ftp;

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

  1045             QFAIL( "Network operation timed out" );

  1046 

  1047         ResMapIt it = resultMap.find( QFtp::Remove );

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

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

  1050 

  1051         QVERIFY( !fileExists( host, 21, user, password, fileToDelete ) );

  1052     }

  1053 }

  1054 

  1055 void tst_QFtp::rename()

  1056 {

  1057     QFETCH( QString, host );

  1058     QFETCH( QString, user );

  1059     QFETCH( QString, password );

  1060     QFETCH( QString, cdDir );

  1061     QFETCH( QString, oldfile );

  1062     QFETCH( QString, newfile );

  1063     QFETCH( QString, createFile );

  1064     QFETCH( QString, renamedFile );

  1065 

  1066     if(oldfile.contains('%'))

  1067         oldfile = oldfile.arg(uniqueExtension);

  1068     if(newfile.contains('%'))

  1069         newfile = newfile.arg(uniqueExtension);

  1070     if(createFile.contains('%'))

  1071         createFile = createFile.arg(uniqueExtension);

  1072     if(renamedFile.contains('%'))

  1073         renamedFile = renamedFile.arg(uniqueExtension);

  1074 

  1075     renameInit( host, user, password, createFile );

  1076 

  1077     init();

  1078     ftp = newFtp();

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

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

  1081     if ( !cdDir.isNull() )

  1082         addCommand( QFtp::Cd, ftp->cd( cdDir ) );

  1083     addCommand( QFtp::Rename, ftp->rename( oldfile, newfile ) );

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

  1085 

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

  1087     delete ftp;

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

  1089         QFAIL( "Network operation timed out" );

  1090 

  1091     ResMapIt it = resultMap.find( QFtp::Rename );

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

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

  1094 

  1095     if ( it.value().success ) {

  1096         QVERIFY( !fileExists( host, 21, user, password, oldfile, cdDir ) );

  1097         QVERIFY( fileExists( host, 21, user, password, newfile, cdDir ) );

  1098         QVERIFY( fileExists( host, 21, user, password, renamedFile ) );

  1099     } else {

  1100         QVERIFY( !fileExists( host, 21, user, password, newfile, cdDir ) );

  1101         QVERIFY( !fileExists( host, 21, user, password, renamedFile ) );

  1102     }

  1103 

  1104     renameCleanup( host, user, password, renamedFile );

  1105 }

  1106 

  1107 /*

  1108   The commandSequence() test does not test any particular function. It rather

  1109   tests a sequence of arbitrary commands specified in the test data.

  1110 */

  1111 class FtpCommand

  1112 {

  1113 public:

  1114     FtpCommand() :

  1115             cmd(QFtp::None)

  1116     { }

  1117 

  1118     FtpCommand( QFtp::Command command ) :

  1119             cmd(command)

  1120     { }

  1121 

  1122     FtpCommand( QFtp::Command command, const QStringList &arguments ) :

  1123             cmd(command), args(arguments)

  1124     { }

  1125 

  1126     FtpCommand( const FtpCommand &c )

  1127     { *this = c; }

  1128 

  1129     FtpCommand &operator=( const FtpCommand &c )

  1130                          {

  1131         this->cmd  = c.cmd;

  1132         this->args = c.args;

  1133         return *this;

  1134     }

  1135