Mercurial Mercurial > oss > FCL > sf > mw > qt / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
tests/auto/qnetworkreply/tst_qnetworkreply.cpp
changeset 30 5dc02b23752f
parent 29 b72c6db6890b
child 37 758a864f9613
equal deleted inserted replaced
29:b72c6db6890b 30:5dc02b23752f 
    80 Q_DECLARE_METATYPE(QAuthenticator*)
 
    80 Q_DECLARE_METATYPE(QAuthenticator*)
 
    81 Q_DECLARE_METATYPE(QNetworkProxy)
 
    81 Q_DECLARE_METATYPE(QNetworkProxy)
 
    82 Q_DECLARE_METATYPE(QNetworkProxyQuery)
 
    82 Q_DECLARE_METATYPE(QNetworkProxyQuery)
 
    83 Q_DECLARE_METATYPE(QList<QNetworkProxy>)
 
    83 Q_DECLARE_METATYPE(QList<QNetworkProxy>)
 
    84 Q_DECLARE_METATYPE(QNetworkReply::NetworkError)
 
    84 Q_DECLARE_METATYPE(QNetworkReply::NetworkError)
 
       
    85 Q_DECLARE_METATYPE(QBuffer*)
 
    85 
    86 
    86 class QNetworkReplyPtr: public QSharedPointer<QNetworkReply>
 
    87 class QNetworkReplyPtr: public QSharedPointer<QNetworkReply>
 
    87 {
 
    88 {
 
    88 public:
 
    89 public:
 
    89     inline QNetworkReplyPtr(QNetworkReply *ptr = 0)
 
    90     inline QNetworkReplyPtr(QNetworkReply *ptr = 0)
 
   126 public:
 
   127 public:
 
   127     tst_QNetworkReply();
 
   128     tst_QNetworkReply();
 
   128     ~tst_QNetworkReply();
 
   129     ~tst_QNetworkReply();
 
   129     QString runSimpleRequest(QNetworkAccessManager::Operation op, const QNetworkRequest &request,
 
   130     QString runSimpleRequest(QNetworkAccessManager::Operation op, const QNetworkRequest &request,
 
   130                              QNetworkReplyPtr &reply, const QByteArray &data = QByteArray());
 
   131                              QNetworkReplyPtr &reply, const QByteArray &data = QByteArray());
 
       
   132 
       
   133     QString runCustomRequest(const QNetworkRequest &request, QNetworkReplyPtr &reply,
 
       
   134                              const QByteArray &verb, QIODevice *data);
 
   131 
   135 
   132 public Q_SLOTS:
 
   136 public Q_SLOTS:
 
   133     void finished();
 
   137     void finished();
 
   134     void gotError();
 
   138     void gotError();
 
   135     void authenticationRequired(QNetworkReply*,QAuthenticator*);
 
   139     void authenticationRequired(QNetworkReply*,QAuthenticator*);
 
   173     void postToHttp();
 
   177     void postToHttp();
 
   174     void deleteFromHttp_data();
 
   178     void deleteFromHttp_data();
 
   175     void deleteFromHttp();
 
   179     void deleteFromHttp();
 
   176     void putGetDeleteGetFromHttp_data();
 
   180     void putGetDeleteGetFromHttp_data();
 
   177     void putGetDeleteGetFromHttp();
 
   181     void putGetDeleteGetFromHttp();
 
       
   182     void sendCustomRequestToHttp_data();
 
       
   183     void sendCustomRequestToHttp();
 
   178 
   184 
   179     void ioGetFromData_data();
 
   185     void ioGetFromData_data();
 
   180     void ioGetFromData();
 
   186     void ioGetFromData();
 
   181     void ioGetFromFileSpecial_data();
 
   187     void ioGetFromFileSpecial_data();
 
   182     void ioGetFromFileSpecial();
 
   188     void ioGetFromFileSpecial();
 
   233     void ioPostToHttpEmptyUploadProgress();
 
   239     void ioPostToHttpEmptyUploadProgress();
 
   234 
   240 
   235     void lastModifiedHeaderForFile();
 
   241     void lastModifiedHeaderForFile();
 
   236     void lastModifiedHeaderForHttp();
 
   242     void lastModifiedHeaderForHttp();
 
   237 
   243 
       
   244     void httpCanReadLine();
 
       
   245 
   238     void rateControl_data();
 
   246     void rateControl_data();
 
   239     void rateControl();
 
   247     void rateControl();
 
   240 
   248 
   241     void downloadProgress_data();
 
   249     void downloadProgress_data();
 
   242     void downloadProgress();
 
   250     void downloadProgress();
 
   517 
   525 
   518         QTcpSocket *active = new QTcpSocket(this);
 
   526         QTcpSocket *active = new QTcpSocket(this);
 
   519         active->connectToHost("127.0.0.1", server.serverPort());
 
   527         active->connectToHost("127.0.0.1", server.serverPort());
 
   520 #ifndef Q_OS_SYMBIAN
 
   528 #ifndef Q_OS_SYMBIAN
 
   521         // need more time as working with embedded
 
   529         // need more time as working with embedded
 
   522 		// device and testing from emualtor
 
   530         // device and testing from emualtor
 
   523 		// things tend to get slower
 
   531         // things tend to get slower
 
   524         if (!active->waitForConnected(1000))
 
   532         if (!active->waitForConnected(1000))
 
   525             return false;
 
   533             return false;
 
   526 
   534 
   527         if (!server.waitForNewConnection(1000))
 
   535         if (!server.waitForNewConnection(1000))
 
   528             return false;
 
   536             return false;
 
   803         return "Network timeout";
 
   811         return "Network timeout";
 
   804     }
 
   812     }
 
   805     return QString();
 
   813     return QString();
 
   806 }
 
   814 }
 
   807 
   815 
       
   816 QString tst_QNetworkReply::runCustomRequest(const QNetworkRequest &request,
 
       
   817                                             QNetworkReplyPtr &reply,
 
       
   818                                             const QByteArray &verb,
 
       
   819                                             QIODevice *data)
 
       
   820 {
 
       
   821     reply = manager.sendCustomRequest(request, verb, data);
 
       
   822     reply->setParent(this);
 
       
   823     connect(reply, SIGNAL(finished()), SLOT(finished()));
 
       
   824     connect(reply, SIGNAL(error(QNetworkReply::NetworkError)), SLOT(gotError()));
 
       
   825 
       
   826     returnCode = Timeout;
 
       
   827     loop = new QEventLoop;
 
       
   828     QTimer::singleShot(20000, loop, SLOT(quit()));
 
       
   829     int code = returnCode == Timeout ? loop->exec() : returnCode;
 
       
   830     delete loop;
 
       
   831     loop = 0;
 
       
   832 
       
   833     switch (code) {
 
       
   834     case Failure:
 
       
   835         return "Request failed: " + reply->errorString();
 
       
   836     case Timeout:
 
       
   837         return "Network timeout";
 
       
   838     }
 
       
   839     return QString();
 
       
   840 }
 
       
   841 
   808 void tst_QNetworkReply::finished()
 
   842 void tst_QNetworkReply::finished()
 
   809 {
 
   843 {
 
   810     loop->exit(returnCode = Success);
 
   844     loop->exit(returnCode = Success);
 
   811 }
 
   845 }
 
   812 
   846 
   898     QCOMPARE(reply->error(), QNetworkReply::ProtocolUnknownError);
 
   932     QCOMPARE(reply->error(), QNetworkReply::ProtocolUnknownError);
 
   899 }
 
   933 }
 
   900 
   934 
   901 void tst_QNetworkReply::getFromData_data()
 
   935 void tst_QNetworkReply::getFromData_data()
 
   902 {
 
   936 {
 
   903 	QTest::addColumn<QString>("request");
 
   937     QTest::addColumn<QString>("request");
 
   904     QTest::addColumn<QByteArray>("expected");
 
   938     QTest::addColumn<QByteArray>("expected");
 
   905     QTest::addColumn<QString>("mimeType");
 
   939     QTest::addColumn<QString>("mimeType");
 
   906 
   940 
   907     const QString defaultMimeType("text/plain;charset=US-ASCII");
 
   941     const QString defaultMimeType("text/plain;charset=US-ASCII");
 
   908 
   942 
   994     QCOMPARE(reply->readAll(), expected);
 
  1028     QCOMPARE(reply->readAll(), expected);
 
   995 }
 
  1029 }
 
   996 
  1030 
   997 void tst_QNetworkReply::getFromFile()
 
  1031 void tst_QNetworkReply::getFromFile()
 
   998 {
 
  1032 {
 
   999 	// create the file:
 
  1033     // create the file:
 
  1000     QTemporaryFile file(QDir::currentPath() + "/temp-XXXXXX");
 
  1034     QTemporaryFile file(QDir::currentPath() + "/temp-XXXXXX");
 
  1001     file.setAutoRemove(true);
 
  1035     file.setAutoRemove(true);
 
  1002     QVERIFY(file.open());
 
  1036     QVERIFY(file.open());
 
  1003 
  1037 
  1004     QNetworkRequest request(QUrl::fromLocalFile(file.fileName()));
 
  1038     QNetworkRequest request(QUrl::fromLocalFile(file.fileName()));
 
  1042     QTest::addColumn<QString>("url");
 
  1076     QTest::addColumn<QString>("url");
 
  1043 
  1077 
  1044     QTest::newRow("resource") << ":/resource" <<  "qrc:/resource";
 
  1078     QTest::newRow("resource") << ":/resource" <<  "qrc:/resource";
 
  1045     QTest::newRow("search-path") << "srcdir:/rfc3252.txt" << "srcdir:/rfc3252.txt";
 
  1079     QTest::newRow("search-path") << "srcdir:/rfc3252.txt" << "srcdir:/rfc3252.txt";
 
  1046     QTest::newRow("bigfile-path") << "srcdir:/bigfile" << "srcdir:/bigfile";
 
  1080     QTest::newRow("bigfile-path") << "srcdir:/bigfile" << "srcdir:/bigfile";
 
       
  1081 #ifdef Q_OS_WIN
 
       
  1082     QTest::newRow("smb-path") << "srcdir:/smb-file.txt" << "file://" + QtNetworkSettings::winServerName() + "/testshare/test.pri";
 
       
  1083 #endif
 
  1047 }
 
  1084 }
 
  1048 
  1085 
  1049 void tst_QNetworkReply::getFromFileSpecial()
 
  1086 void tst_QNetworkReply::getFromFileSpecial()
 
  1050 {
 
  1087 {
 
  1051 	QFETCH(QString, fileName);
 
  1088     QFETCH(QString, fileName);
 
  1052     QFETCH(QString, url);
 
  1089     QFETCH(QString, url);
 
  1053 
  1090 
  1054     // open the resource so we can find out its size
 
  1091     // open the resource so we can find out its size
 
  1055     QFile resource(fileName);
 
  1092     QFile resource(fileName);
 
  1056     QVERIFY(resource.open(QIODevice::ReadOnly));
 
  1093     QVERIFY(resource.open(QIODevice::ReadOnly));
 
  1076     QTest::newRow("bigfile") << SRCDIR "/bigfile" << "ftp://" + QtNetworkSettings::serverName() + "/qtest/bigfile";
 
  1113     QTest::newRow("bigfile") << SRCDIR "/bigfile" << "ftp://" + QtNetworkSettings::serverName() + "/qtest/bigfile";
 
  1077 }
 
  1114 }
 
  1078 
  1115 
  1079 void tst_QNetworkReply::getFromFtp()
 
  1116 void tst_QNetworkReply::getFromFtp()
 
  1080 {
 
  1117 {
 
  1081 	QFETCH(QString, referenceName);
 
  1118     QFETCH(QString, referenceName);
 
  1082     QFETCH(QString, url);
 
  1119     QFETCH(QString, url);
 
  1083 
  1120 
  1084     QFile reference(referenceName);
 
  1121     QFile reference(referenceName);
 
  1085     QVERIFY(reference.open(QIODevice::ReadOnly));
 
  1122     QVERIFY(reference.open(QIODevice::ReadOnly));
 
  1086 
  1123 
  1105     QTest::newRow("bigfile-internal") << SRCDIR "/bigfile" << "http://" + QtNetworkSettings::serverName() + "/qtest/bigfile";
 
  1142     QTest::newRow("bigfile-internal") << SRCDIR "/bigfile" << "http://" + QtNetworkSettings::serverName() + "/qtest/bigfile";
 
  1106 }
 
  1143 }
 
  1107 
  1144 
  1108 void tst_QNetworkReply::getFromHttp()
 
  1145 void tst_QNetworkReply::getFromHttp()
 
  1109 {
 
  1146 {
 
  1110 	QFETCH(QString, referenceName);
 
  1147     QFETCH(QString, referenceName);
 
  1111     QFETCH(QString, url);
 
  1148     QFETCH(QString, url);
 
  1112 
  1149 
  1113     QFile reference(referenceName);
 
  1150     QFile reference(referenceName);
 
  1114     QVERIFY(reference.open(QIODevice::ReadOnly));
 
  1151     QVERIFY(reference.open(QIODevice::ReadOnly));
 
  1115 
  1152 
  1461     QCOMPARE(reply->error(), get2Error);
 
  1498     QCOMPARE(reply->error(), get2Error);
 
  1462     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), get2ResultCode);
 
  1499     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), get2ResultCode);
 
  1463 
  1500 
  1464 }
 
  1501 }
 
  1465 
  1502 
       
  1503 void tst_QNetworkReply::sendCustomRequestToHttp_data()
 
       
  1504 {
 
       
  1505     QTest::addColumn<QUrl>("url");
 
       
  1506     QTest::addColumn<QByteArray>("verb");
 
       
  1507     QTest::addColumn<QBuffer *>("device");
 
       
  1508     QTest::addColumn<int>("resultCode");
 
       
  1509     QTest::addColumn<QNetworkReply::NetworkError>("error");
 
       
  1510     QTest::addColumn<QByteArray>("expectedContent");
 
       
  1511 
       
  1512     QTest::newRow("options") << QUrl("http://" + QtNetworkSettings::serverName()) <<
 
       
  1513             QByteArray("OPTIONS") << (QBuffer *) 0 << 200 << QNetworkReply::NoError << QByteArray();
 
       
  1514     QTest::newRow("trace") << QUrl("http://" + QtNetworkSettings::serverName()) <<
 
       
  1515             QByteArray("TRACE") << (QBuffer *) 0 << 200 << QNetworkReply::NoError << QByteArray();
 
       
  1516     QTest::newRow("connect") << QUrl("http://" + QtNetworkSettings::serverName()) <<
 
       
  1517             QByteArray("CONNECT") << (QBuffer *) 0 << 400 << QNetworkReply::UnknownContentError << QByteArray(); // 400 = Bad Request
 
       
  1518     QTest::newRow("nonsense") << QUrl("http://" + QtNetworkSettings::serverName()) <<
 
       
  1519             QByteArray("NONSENSE") << (QBuffer *) 0 << 501 << QNetworkReply::ProtocolUnknownError << QByteArray(); // 501 = Method Not Implemented
 
       
  1520 
       
  1521     QByteArray ba("test");
 
       
  1522     QBuffer *buffer = new QBuffer;
 
       
  1523     buffer->setData(ba);
 
       
  1524     buffer->open(QIODevice::ReadOnly);
 
       
  1525     QTest::newRow("post") << QUrl("http://" + QtNetworkSettings::serverName() + "/qtest/cgi-bin/md5sum.cgi") << QByteArray("POST")
 
       
  1526             << buffer << 200 << QNetworkReply::NoError << QByteArray("098f6bcd4621d373cade4e832627b4f6\n");
 
       
  1527 
       
  1528     QByteArray ba2("test");
 
       
  1529     QBuffer *buffer2 = new QBuffer;
 
       
  1530     buffer2->setData(ba2);
 
       
  1531     buffer2->open(QIODevice::ReadOnly);
 
       
  1532     QTest::newRow("put") << QUrl("http://" + QtNetworkSettings::serverName() + "/qtest/cgi-bin/md5sum.cgi") << QByteArray("PUT")
 
       
  1533             << buffer2 << 200 << QNetworkReply::NoError << QByteArray("098f6bcd4621d373cade4e832627b4f6\n");
 
       
  1534 }
 
       
  1535 
       
  1536 void tst_QNetworkReply::sendCustomRequestToHttp()
 
       
  1537 {
 
       
  1538     QFETCH(QUrl, url);
 
       
  1539     QNetworkRequest request(url);
 
       
  1540     QNetworkReplyPtr reply;
 
       
  1541     QFETCH(QByteArray, verb);
 
       
  1542     QFETCH(QBuffer *, device);
 
       
  1543     runCustomRequest(request, reply, verb, device);
 
       
  1544     QCOMPARE(reply->url(), url);
 
       
  1545     QFETCH(QNetworkReply::NetworkError, error);
 
       
  1546     QCOMPARE(reply->error(), error);
 
       
  1547     QFETCH(int, resultCode);
 
       
  1548     QCOMPARE(reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt(), resultCode);
 
       
  1549     QFETCH(QByteArray, expectedContent);
 
       
  1550     if (! expectedContent.isEmpty())
 
       
  1551         QCOMPARE(reply->readAll(), expectedContent);
 
       
  1552 }
 
       
  1553 
  1466 void tst_QNetworkReply::ioGetFromData_data()
 
  1554 void tst_QNetworkReply::ioGetFromData_data()
 
  1467 {
 
  1555 {
 
  1468     QTest::addColumn<QString>("urlStr");
 
  1556     QTest::addColumn<QString>("urlStr");
 
  1469     QTest::addColumn<QByteArray>("data");
 
  1557     QTest::addColumn<QByteArray>("data");
 
  1470 
  1558 
  3296     realDate.setTimeSpec(Qt::UTC);
 
  3384     realDate.setTimeSpec(Qt::UTC);
 
  3297 
  3385 
  3298     QCOMPARE(header, realDate);
 
  3386     QCOMPARE(header, realDate);
 
  3299 }
 
  3387 }
 
  3300 
  3388 
       
  3389 void tst_QNetworkReply::httpCanReadLine()
 
       
  3390 {
 
       
  3391     QNetworkRequest request(QUrl("http://" + QtNetworkSettings::serverName() + "/qtest/rfc3252.txt"));
 
       
  3392     QNetworkReplyPtr reply = manager.get(request);
 
       
  3393 
       
  3394     connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
 
       
  3395     QTestEventLoop::instance().enterLoop(10);
 
       
  3396     QVERIFY(!QTestEventLoop::instance().timeout());
 
       
  3397     QCOMPARE(reply->error(), QNetworkReply::NoError);
 
       
  3398 
       
  3399     QVERIFY(reply->canReadLine());
 
       
  3400     QVERIFY(!reply->readAll().isEmpty());
 
       
  3401     QVERIFY(!reply->canReadLine());
 
       
  3402 }
 
       
  3403 
  3301 void tst_QNetworkReply::rateControl_data()
 
  3404 void tst_QNetworkReply::rateControl_data()
 
  3302 {
 
  3405 {
 
  3303     QTest::addColumn<int>("rate");
 
  3406     QTest::addColumn<int>("rate");
 
  3304 
  3407 
  3305     QTest::newRow("15") << 15;
 
  3408     QTest::newRow("15") << 15;
 
  3359     QTest::newRow("small") << 4;
 
  3462     QTest::newRow("small") << 4;
 
  3360 #ifndef Q_OS_SYMBIAN
 
  3463 #ifndef Q_OS_SYMBIAN
 
  3361     QTest::newRow("big") << 4096;
 
  3464     QTest::newRow("big") << 4096;
 
  3362 #else
 
  3465 #else
 
  3363     // it can run even with 4096
 
  3466     // it can run even with 4096
 
  3364 	// but it takes lot time
 
  3467     // but it takes lot time
 
  3365 	//especially on emulator
 
  3468     //especially on emulator
 
  3366     QTest::newRow("big") << 1024;
 
  3469     QTest::newRow("big") << 1024;
 
  3367 #endif
 
  3470 #endif
 
  3368 }
 
  3471 }
 
  3369 
  3472 
  3370 void tst_QNetworkReply::downloadProgress()
 
  3473 void tst_QNetworkReply::downloadProgress()
 
  3549     QTest::newRow("invalid-cookie-domain") << "a=b; domain=.example.com" << header << jar;
 
  3652     QTest::newRow("invalid-cookie-domain") << "a=b; domain=.example.com" << header << jar;
 
  3550 }
 
  3653 }
 
  3551 
  3654 
  3552 void tst_QNetworkReply::receiveCookiesFromHttp()
 
  3655 void tst_QNetworkReply::receiveCookiesFromHttp()
 
  3553 {
 
  3656 {
 
  3554 	QFETCH(QString, cookieString);
 
  3657     QFETCH(QString, cookieString);
 
  3555 
  3658 
  3556     QByteArray data = cookieString.toLatin1() + '\n';
 
  3659     QByteArray data = cookieString.toLatin1() + '\n';
 
  3557     QUrl url("http://" + QtNetworkSettings::serverName() + "/qtest/cgi-bin/set-cookie.cgi");
 
  3660     QUrl url("http://" + QtNetworkSettings::serverName() + "/qtest/cgi-bin/set-cookie.cgi");
 
  3558     QNetworkRequest request(url);
 
  3661     QNetworkRequest request(url);
 
  3559     QNetworkReplyPtr reply;
 
  3662     QNetworkReplyPtr reply;
 
  3916         reply1->deleteLater(); // only do it if it was not done earlier
 
  4019         reply1->deleteLater(); // only do it if it was not done earlier
 
  3917     reply2->deleteLater();
 
  4020     reply2->deleteLater();
 
  3918 }
 
  4021 }
 
  3919 
  4022 
  3920 class HttpReUsingConnectionFromFinishedSlot : public QObject {
 
  4023 class HttpReUsingConnectionFromFinishedSlot : public QObject {
 
  3921     Q_OBJECT;
 
  4024     Q_OBJECT
 
  3922 public:
 
  4025 public:
 
  3923     QNetworkReply* reply1;
 
  4026     QNetworkReply* reply1;
 
  3924     QNetworkReply* reply2;
 
  4027     QNetworkReply* reply2;
 
  3925     QUrl url;
 
  4028     QUrl url;
 
  3926     QNetworkAccessManager manager;
 
  4029     QNetworkAccessManager manager;
FCL/sf/mw/qt