--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tests/auto/qnetworkrequest/tst_qnetworkrequest.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,496 @@
+/****************************************************************************
+**
+** 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/QUrl>
+#include <QtNetwork/QNetworkRequest>
+#include <QtNetwork/QNetworkCookie>
+
+Q_DECLARE_METATYPE(QList<QByteArray>)
+Q_DECLARE_METATYPE(QNetworkRequest::KnownHeaders)
+Q_DECLARE_METATYPE(QVariant)
+
+class tst_QNetworkRequest: public QObject
+{
+ Q_OBJECT
+
+private slots:
+ void ctor_data();
+ void ctor();
+ void setUrl_data();
+ void setUrl();
+ void setRawHeader_data();
+ void setRawHeader();
+ void rawHeaderList_data();
+ void rawHeaderList();
+ void setHeader_data();
+ void setHeader();
+ void rawHeaderParsing_data();
+ void rawHeaderParsing();
+ void originatingObject();
+
+ void removeHeader();
+};
+
+QT_BEGIN_NAMESPACE
+
+namespace QTest {
+ 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
+
+void tst_QNetworkRequest::ctor_data()
+{
+ QTest::addColumn<QUrl>("url");
+
+ QTest::newRow("nothing") << QUrl();
+ QTest::newRow("empty") << QUrl();
+ QTest::newRow("http") << QUrl("http://qt.nokia.com");
+}
+
+void tst_QNetworkRequest::ctor()
+{
+ QFETCH(QUrl, url);
+
+ if (qstrcmp(QTest::currentDataTag(), "nothing") == 0) {
+ QNetworkRequest request;
+ QCOMPARE(request.url(), url);
+ } else {
+ QNetworkRequest request(url);
+ QCOMPARE(request.url(), url);
+ }
+}
+
+void tst_QNetworkRequest::setUrl_data()
+{
+ ctor_data();
+}
+
+void tst_QNetworkRequest::setUrl()
+{
+ QFETCH(QUrl, url);
+ QNetworkRequest request;
+
+ if (qstrcmp(QTest::currentDataTag(), "nothing") != 0)
+ request.setUrl(url);
+
+ QCOMPARE(request.url(), url);
+}
+
+void tst_QNetworkRequest::setRawHeader_data()
+{
+ QTest::addColumn<QByteArray>("header");
+ QTest::addColumn<QByteArray>("value");
+ QTest::addColumn<QByteArray>("headerToGet");
+ QTest::addColumn<QByteArray>("expectedValue");
+ QTest::addColumn<bool>("hasHeader");
+
+ QTest::newRow("null-header") << QByteArray() << QByteArray("abc")
+ << QByteArray() << QByteArray() << false;
+ QTest::newRow("empty-header") << QByteArray("") << QByteArray("abc")
+ << QByteArray("") << QByteArray() << false;
+ QTest::newRow("null-value") << QByteArray("foo") << QByteArray()
+ << QByteArray("foo") << QByteArray() << false;
+ QTest::newRow("empty-value") << QByteArray("foo") << QByteArray("")
+ << QByteArray("foo") << QByteArray("") << true;
+ QTest::newRow("empty-value-vs-null") << QByteArray("foo") << QByteArray("")
+ << QByteArray("foo") << QByteArray() << true;
+
+ QTest::newRow("UPPER-UPPER") << QByteArray("FOO") << QByteArray("abc")
+ << QByteArray("FOO") << QByteArray("abc") << true;
+ QTest::newRow("UPPER-Mixed") << QByteArray("FOO") << QByteArray("abc")
+ << QByteArray("Foo") << QByteArray("abc") << true;
+ QTest::newRow("UPPER-lower") << QByteArray("FOO") << QByteArray("abc")
+ << QByteArray("foo") << QByteArray("abc") << true;
+ QTest::newRow("Mixed-UPPER") << QByteArray("Foo") << QByteArray("abc")
+ << QByteArray("FOO") << QByteArray("abc") << true;
+ QTest::newRow("Mixed-Mixed") << QByteArray("Foo") << QByteArray("abc")
+ << QByteArray("Foo") << QByteArray("abc") << true;
+ QTest::newRow("Mixed-lower") << QByteArray("Foo") << QByteArray("abc")
+ << QByteArray("foo") << QByteArray("abc") << true;
+ QTest::newRow("lower-UPPER") << QByteArray("foo") << QByteArray("abc")
+ << QByteArray("FOO") << QByteArray("abc") << true;
+ QTest::newRow("lower-Mixed") << QByteArray("foo") << QByteArray("abc")
+ << QByteArray("Foo") << QByteArray("abc") << true;
+ QTest::newRow("lower-lower") << QByteArray("foo") << QByteArray("abc")
+ << QByteArray("foo") << QByteArray("abc") << true;
+}
+
+void tst_QNetworkRequest::setRawHeader()
+{
+ QFETCH(QByteArray, header);
+ QFETCH(QByteArray, value);
+ QFETCH(QByteArray, headerToGet);
+ QFETCH(QByteArray, expectedValue);
+ QFETCH(bool, hasHeader);
+
+ QNetworkRequest request;
+ request.setRawHeader(header, value);
+
+ QCOMPARE(request.hasRawHeader(headerToGet), hasHeader);
+ QCOMPARE(request.rawHeader(headerToGet), expectedValue);
+}
+
+void tst_QNetworkRequest::rawHeaderList_data()
+{
+ QTest::addColumn<QList<QByteArray> >("set");
+ QTest::addColumn<QList<QByteArray> >("expected");
+
+ QTest::newRow("empty") << QList<QByteArray>() << QList<QByteArray>();
+
+ QList<QByteArray> set;
+ QList<QByteArray> expected;
+
+ set << "foo";
+ expected = set;
+ QTest::newRow("one") << set << expected;
+
+ set << "bar";
+ expected = set;
+ QTest::newRow("two") << set << expected;
+
+ set.clear();
+ expected.clear();
+ set << "foo" << "foo";
+ expected << "foo";
+ QTest::newRow("repeated") << set << expected;
+
+ set.clear();
+ expected.clear();
+ set << "foo" << "bar" << "foo";
+ expected << "bar" << "foo";
+ QTest::newRow("repeated-interleaved") << set << expected;
+}
+
+void tst_QNetworkRequest::rawHeaderList()
+{
+ QFETCH(QList<QByteArray>, set);
+ QFETCH(QList<QByteArray>, expected);
+
+ QNetworkRequest request;
+ foreach (QByteArray header, set)
+ request.setRawHeader(header, "a value");
+
+ QList<QByteArray> got = request.rawHeaderList();
+ QCOMPARE(got.size(), expected.size());
+ for (int i = 0; i < got.size(); ++i)
+ QCOMPARE(got.at(i), expected.at(i));
+}
+
+void tst_QNetworkRequest::setHeader_data()
+{
+ QTest::addColumn<QNetworkRequest::KnownHeaders>("cookedHeader");
+ QTest::addColumn<QVariant>("cookedValue");
+ QTest::addColumn<bool>("success");
+ QTest::addColumn<QString>("rawHeader");
+ QTest::addColumn<QString>("rawValue");
+
+ QTest::newRow("Content-Type-Null") << QNetworkRequest::ContentTypeHeader << QVariant()
+ << false << "Content-Type" << "";
+ QTest::newRow("Content-Type-String") << QNetworkRequest::ContentTypeHeader << QVariant("text/html")
+ << true
+ << "Content-Type" << "text/html";
+ QTest::newRow("Content-Type-ByteArray") << QNetworkRequest::ContentTypeHeader
+ << QVariant("text/html") << true
+ << "Content-Type" << "text/html";
+
+ QTest::newRow("Content-Length-Int") << QNetworkRequest::ContentLengthHeader << QVariant(1)
+ << true << "Content-Length" << "1";
+ QTest::newRow("Content-Length-Int64") << QNetworkRequest::ContentLengthHeader << QVariant(qint64(1))
+ << true << "Content-Length" << "1";
+
+ QTest::newRow("Location-String") << QNetworkRequest::LocationHeader << QVariant("http://foo/with space")
+ << true << "Location" << "http://foo/with space";
+ QTest::newRow("Location-ByteArray") << QNetworkRequest::LocationHeader
+ << QVariant("http://foo/with space")
+ << true << "Location" << "http://foo/with space";
+ QTest::newRow("Location-Url") << QNetworkRequest::LocationHeader
+ << QVariant(QUrl("http://foo/with space"))
+ << true << "Location" << "http://foo/with%20space";
+
+ QTest::newRow("Last-Modified-Date") << QNetworkRequest::LastModifiedHeader
+ << QVariant(QDate(2007, 11, 01))
+ << true << "Last-Modified"
+ << "Thu, 01 Nov 2007 00:00:00 GMT";
+ QTest::newRow("Last-Modified-DateTime") << QNetworkRequest::LastModifiedHeader
+ << QVariant(QDateTime(QDate(2007, 11, 01),
+ QTime(18, 8, 30),
+ Qt::UTC))
+ << true << "Last-Modified"
+ << "Thu, 01 Nov 2007 18:08:30 GMT";
+
+ QNetworkCookie cookie;
+ cookie.setName("a");
+ cookie.setValue("b");
+ QTest::newRow("Cookie-1") << QNetworkRequest::CookieHeader
+ << qVariantFromValue(QList<QNetworkCookie>() << cookie)
+ << true << "Cookie"
+ << "a=b";
+ QTest::newRow("SetCookie-1") << QNetworkRequest::SetCookieHeader
+ << qVariantFromValue(QList<QNetworkCookie>() << cookie)
+ << true << "Set-Cookie"
+ << "a=b";
+
+ cookie.setPath("/");
+ QTest::newRow("Cookie-2") << QNetworkRequest::CookieHeader
+ << qVariantFromValue(QList<QNetworkCookie>() << cookie)
+ << true << "Cookie"
+ << "a=b";
+ QTest::newRow("SetCookie-2") << QNetworkRequest::SetCookieHeader
+ << qVariantFromValue(QList<QNetworkCookie>() << cookie)
+ << true << "Set-Cookie"
+ << "a=b; path=/";
+
+ QNetworkCookie cookie2;
+ cookie2.setName("c");
+ cookie2.setValue("d");
+ QTest::newRow("Cookie-3") << QNetworkRequest::CookieHeader
+ << qVariantFromValue(QList<QNetworkCookie>() << cookie << cookie2)
+ << true << "Cookie"
+ << "a=b; c=d";
+ QTest::newRow("SetCookie-3") << QNetworkRequest::SetCookieHeader
+ << qVariantFromValue(QList<QNetworkCookie>() << cookie << cookie2)
+ << true << "Set-Cookie"
+ << "a=b; path=/, c=d";
+}
+
+void tst_QNetworkRequest::setHeader()
+{
+ QFETCH(QNetworkRequest::KnownHeaders, cookedHeader);
+ QFETCH(QVariant, cookedValue);
+ QFETCH(bool, success);
+ QFETCH(QString, rawHeader);
+ QFETCH(QString, rawValue);
+
+ QNetworkRequest request;
+ request.setHeader(cookedHeader, cookedValue);
+
+ QCOMPARE(request.header(cookedHeader).isNull(), !success);
+ QCOMPARE(request.hasRawHeader(rawHeader.toLatin1()), success);
+ QCOMPARE(request.rawHeader(rawHeader.toLatin1()).isEmpty(), !success);
+
+ if (success) {
+ QCOMPARE(request.header(cookedHeader), cookedValue);
+ QCOMPARE(QString(request.rawHeader(rawHeader.toLatin1())), rawValue);
+ }
+}
+
+void tst_QNetworkRequest::rawHeaderParsing_data()
+{
+ QTest::addColumn<QNetworkRequest::KnownHeaders>("cookedHeader");
+ QTest::addColumn<QVariant>("cookedValue");
+ QTest::addColumn<bool>("success");
+ QTest::addColumn<QString>("rawHeader");
+ QTest::addColumn<QString>("rawValue");
+
+ QTest::newRow("Content-Type") << QNetworkRequest::ContentTypeHeader << QVariant("text/html")
+ << true
+ << "Content-Type" << "text/html";
+ QTest::newRow("Content-Length") << QNetworkRequest::ContentLengthHeader << QVariant(qint64(1))
+ << true << "Content-Length" << " 1 ";
+ QTest::newRow("Location") << QNetworkRequest::LocationHeader
+ << QVariant(QUrl("http://foo/with space"))
+ << true << "Location" << "http://foo/with%20space";
+ QTest::newRow("Last-Modified-RFC1123") << QNetworkRequest::LastModifiedHeader
+ << QVariant(QDateTime(QDate(1994, 11, 06),
+ QTime(8, 49, 37),
+ Qt::UTC))
+ << true << "Last-Modified"
+ << "Sun, 06 Nov 1994 08:49:37 GMT";
+ QTest::newRow("Last-Modified-RFC850") << QNetworkRequest::LastModifiedHeader
+ << QVariant(QDateTime(QDate(1994, 11, 06),
+ QTime(8, 49, 37),
+ Qt::UTC))
+ << true << "Last-Modified"
+ << "Sunday, 06-Nov-94 08:49:37 GMT";
+ QTest::newRow("Last-Modified-asctime") << QNetworkRequest::LastModifiedHeader
+ << QVariant(QDateTime(QDate(1994, 11, 06),
+ QTime(8, 49, 37),
+ Qt::UTC))
+ << true << "Last-Modified"
+ << "Sun Nov 6 08:49:37 1994";
+
+ QTest::newRow("Content-Length-invalid1") << QNetworkRequest::ContentLengthHeader << QVariant()
+ << false << "Content-Length" << "1a";
+ QTest::newRow("Content-Length-invalid2") << QNetworkRequest::ContentLengthHeader << QVariant()
+ << false << "Content-Length" << "a";
+
+
+ QTest::newRow("Location-invalid1") << QNetworkRequest::LocationHeader << QVariant() << false
+ << "Location" << "abc";
+ QTest::newRow("Location-invalid2") << QNetworkRequest::LocationHeader << QVariant() << false
+ << "Location" << "1http://foo";
+ QTest::newRow("Location-invalid3") << QNetworkRequest::LocationHeader << QVariant() << false
+ << "Location" << "http://foo/%gg";
+
+ // don't test for invalid dates because we may want to support broken servers in the future
+
+ QNetworkCookie cookie;
+ cookie.setName("a");
+ cookie.setValue("b");
+ QTest::newRow("Cookie-1") << QNetworkRequest::CookieHeader
+ << qVariantFromValue(QList<QNetworkCookie>() << cookie)
+ << true << "Cookie"
+ << "a=b";
+ QTest::newRow("SetCookie-1") << QNetworkRequest::SetCookieHeader
+ << qVariantFromValue(QList<QNetworkCookie>() << cookie)
+ << true << "Set-Cookie"
+ << "a=b";
+
+ cookie.setPath("/");
+ QTest::newRow("SetCookie-2") << QNetworkRequest::SetCookieHeader
+ << qVariantFromValue(QList<QNetworkCookie>() << cookie)
+ << true << "Set-Cookie"
+ << "a=b; path=/";
+
+ QNetworkCookie cookie2;
+ cookie.setPath("");
+ cookie2.setName("c");
+ cookie2.setValue("d");
+ QTest::newRow("Cookie-3") << QNetworkRequest::CookieHeader
+ << qVariantFromValue(QList<QNetworkCookie>() << cookie << cookie2)
+ << true << "Cookie"
+ << "a=b; c=d";
+ cookie.setPath("/");
+ QTest::newRow("SetCookie-3") << QNetworkRequest::SetCookieHeader
+ << qVariantFromValue(QList<QNetworkCookie>() << cookie << cookie2)
+ << true << "Set-Cookie"
+ << "a=b; path=/, c=d";
+}
+
+void tst_QNetworkRequest::rawHeaderParsing()
+{
+ QFETCH(QNetworkRequest::KnownHeaders, cookedHeader);
+ QFETCH(QVariant, cookedValue);
+ QFETCH(bool, success);
+ QFETCH(QString, rawHeader);
+ QFETCH(QString, rawValue);
+
+ QNetworkRequest request;
+ request.setRawHeader(rawHeader.toLatin1(), rawValue.toLatin1());
+
+ // even if it doesn't parse, it's as a raw header
+ QVERIFY(request.hasRawHeader(rawHeader.toLatin1()));
+ QVERIFY(request.hasRawHeader(rawHeader.toLower().toLatin1()));
+ QCOMPARE(QString(request.rawHeader(rawHeader.toLatin1())), rawValue);
+
+ QCOMPARE(request.header(cookedHeader).isNull(), !success);
+ if (cookedValue.type() != QVariant::UserType)
+ QCOMPARE(request.header(cookedHeader), cookedValue);
+ else if (cookedValue.userType() == qMetaTypeId<QList<QNetworkCookie> >())
+ QCOMPARE(qvariant_cast<QList<QNetworkCookie> >(request.header(cookedHeader)),
+ qvariant_cast<QList<QNetworkCookie> >(cookedValue));
+}
+
+void tst_QNetworkRequest::removeHeader()
+{
+ QNetworkRequest request;
+
+ request.setRawHeader("Foo", "1");
+ QVERIFY(request.hasRawHeader("Foo"));
+ QVERIFY(request.hasRawHeader("foo"));
+ request.setRawHeader("Foo", QByteArray());
+ QVERIFY(!request.hasRawHeader("Foo"));
+
+ // same, but remove with different capitalisation
+ request.setRawHeader("Foo", "1");
+ QVERIFY(request.hasRawHeader("Foo"));
+ QVERIFY(request.hasRawHeader("foo"));
+ request.setRawHeader("foo", QByteArray());
+ QVERIFY(!request.hasRawHeader("Foo"));
+
+ // same, but not the first
+ request.setRawHeader("Bar", "2");
+ request.setRawHeader("Foo", "1");
+ QVERIFY(request.hasRawHeader("Foo"));
+ QVERIFY(request.hasRawHeader("foo"));
+ request.setRawHeader("foo", QByteArray());
+ QVERIFY(!request.hasRawHeader("Foo"));
+ QVERIFY(request.hasRawHeader("bar"));
+
+ // same, but not the first nor last
+ request.setRawHeader("Foo", "1");
+ request.setRawHeader("Bar", "3");
+ QVERIFY(request.hasRawHeader("Foo"));
+ QVERIFY(request.hasRawHeader("foo"));
+ request.setRawHeader("foo", QByteArray());
+ QVERIFY(!request.hasRawHeader("Foo"));
+ QVERIFY(request.hasRawHeader("bar"));
+}
+
+void tst_QNetworkRequest::originatingObject()
+{
+ QNetworkRequest request;
+
+ QVERIFY(!request.originatingObject());
+
+ {
+ QObject dummy;
+ request.setOriginatingObject(&dummy);
+ QCOMPARE(request.originatingObject(), &dummy);
+ }
+
+ QVERIFY(!request.originatingObject());
+}
+
+QTEST_MAIN(tst_QNetworkRequest)
+#include "tst_qnetworkrequest.moc"