qt/qtbase/tests/auto/network/access/qnetworkrequest/tst_qnetworkrequest.cpp

Revision control

Copy as Markdown

// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
#include <QTest>
#if QT_CONFIG(http)
#include <QtNetwork/QHttp1Configuration>
#include <QtNetwork/QHttp2Configuration>
#endif
#include <QtNetwork/QNetworkRequest>
#include <QtNetwork/QNetworkCookie>
#include <QtCore/QDateTime>
#include <QtCore/QTimeZone>
#include <QtCore/QUrl>
Q_DECLARE_METATYPE(QNetworkRequest::KnownHeaders)
class tst_QNetworkRequest: public QObject
{
Q_OBJECT
private slots:
void ctor_data();
void ctor();
void implicitDefaultCtor();
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 setHeaders_data();
void setHeaders();
void operatorEqual_data();
void operatorEqual();
void removeHeader();
};
void tst_QNetworkRequest::ctor_data()
{
QTest::addColumn<QUrl>("url");
QTest::newRow("nothing") << QUrl();
QTest::newRow("empty") << QUrl();
QTest::newRow("http") << QUrl("http://qt-project.org");
}
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::implicitDefaultCtor()
{
QNetworkRequest r = {};
Q_UNUSED(r);
}
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(const QList<QByteArray>, set);
QFETCH(QList<QByteArray>, expected);
QNetworkRequest request;
for (const 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-UTC")
<< QNetworkRequest::LastModifiedHeader
<< QVariant(QDateTime(QDate(2007, 11, 1), QTime(18, 8, 30), QTimeZone::UTC))
<< true << "Last-Modified" << "Thu, 01 Nov 2007 18:08:30 GMT";
// QTBUG-80666: format dates correctly (as GMT) even if the date passed in isn't in UTC:
QTest::newRow("Last-Modified-DateTime-Local")
<< QNetworkRequest::LastModifiedHeader
<< QVariant(QDateTime(QDate(2007, 11, 1), QTime(18, 8, 30), QTimeZone::UTC).toLocalTime())
<< true << "Last-Modified" << "Thu, 01 Nov 2007 18:08:30 GMT";
QTest::newRow("Last-Modified-DateTime-Offset")
<< QNetworkRequest::LastModifiedHeader
<< QVariant(QDateTime(QDate(2007, 11, 1), QTime(18, 8, 30),
QTimeZone::UTC).toOffsetFromUtc(3600))
<< true << "Last-Modified" << "Thu, 01 Nov 2007 18:08:30 GMT";
#if QT_CONFIG(timezone)
QTimeZone cet("Europe/Oslo");
if (cet.isValid()) {
QTest::newRow("Last-Modified-DateTime-CET")
<< QNetworkRequest::LastModifiedHeader
<< QVariant(QDateTime(QDate(2007, 11, 1), QTime(18, 8, 30),
QTimeZone::UTC).toTimeZone(cet))
<< true << "Last-Modified" << "Thu, 01 Nov 2007 18:08:30 GMT";
}
#endif
QTest::newRow("If-Modified-Since-Date") << QNetworkRequest::IfModifiedSinceHeader
<< QVariant(QDate(2017, 7, 01))
<< true << "If-Modified-Since"
<< "Sat, 01 Jul 2017 00:00:00 GMT";
QTest::newRow("If-Modified-Since-DateTime") << QNetworkRequest::IfModifiedSinceHeader
<< QVariant(QDateTime(QDate(2017, 7, 01),
QTime(3, 14, 15),
QTimeZone::UTC))
<< true << "If-Modified-Since"
<< "Sat, 01 Jul 2017 03:14:15 GMT";
QTest::newRow("Etag-strong") << QNetworkRequest::ETagHeader << QVariant(R"("xyzzy")")
<< true << "ETag" << R"("xyzzy")";
QTest::newRow("Etag-weak") << QNetworkRequest::ETagHeader << QVariant(R"(W/"xyzzy")")
<< true << "ETag" << R"(W/"xyzzy")";
QTest::newRow("Etag-empty") << QNetworkRequest::ETagHeader << QVariant(R"("")")
<< true << "ETag" << R"("")";
QTest::newRow("If-Match-empty") << QNetworkRequest::IfMatchHeader << QVariant(R"("")")
<< true << "If-Match" << R"("")";
QTest::newRow("If-Match-any") << QNetworkRequest::IfMatchHeader << QVariant(R"("*")")
<< true << "If-Match" << R"("*")";
QTest::newRow("If-Match-single") << QNetworkRequest::IfMatchHeader << QVariant(R"("xyzzy")")
<< true << "If-Match" << R"("xyzzy")";
QTest::newRow("If-Match-multiple") << QNetworkRequest::IfMatchHeader
<< QVariant(R"("xyzzy", "r2d2xxxx", "c3piozzzz")")
<< true << "If-Match"
<< R"("xyzzy", "r2d2xxxx", "c3piozzzz")";
QTest::newRow("If-None-Match-empty") << QNetworkRequest::IfNoneMatchHeader << QVariant(R"("")")
<< true << "If-None-Match" << R"("")";
QTest::newRow("If-None-Match-any") << QNetworkRequest::IfNoneMatchHeader << QVariant(R"("*")")
<< true << "If-None-Match" << R"("*")";
QTest::newRow("If-None-Match-single") << QNetworkRequest::IfNoneMatchHeader << QVariant(R"("xyzzy")")
<< true << "If-None-Match" << R"("xyzzy")";
QTest::newRow("If-None-Match-multiple") << QNetworkRequest::IfNoneMatchHeader
<< QVariant(R"("xyzzy", W/"r2d2xxxx", "c3piozzzz")")
<< true << "If-None-Match"
<< R"("xyzzy", W/"r2d2xxxx", "c3piozzzz")";
QNetworkCookie cookie;
cookie.setName("a");
cookie.setValue("b");
QTest::newRow("Cookie-1") << QNetworkRequest::CookieHeader
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Cookie"
<< "a=b";
QTest::newRow("SetCookie-1") << QNetworkRequest::SetCookieHeader
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Set-Cookie"
<< "a=b";
cookie.setPath("/");
QTest::newRow("Cookie-2") << QNetworkRequest::CookieHeader
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Cookie"
<< "a=b";
QTest::newRow("SetCookie-2") << QNetworkRequest::SetCookieHeader
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Set-Cookie"
<< "a=b; path=/";
QNetworkCookie cookie2;
cookie2.setName("c");
cookie2.setValue("d");
QTest::newRow("Cookie-3") << QNetworkRequest::CookieHeader
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< true << "Cookie"
<< "a=b; c=d";
QTest::newRow("SetCookie-3") << QNetworkRequest::SetCookieHeader
<< QVariant::fromValue(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),
QTimeZone::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),
QTimeZone::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),
QTimeZone::UTC))
<< true << "Last-Modified"
<< "Sun Nov 6 08:49:37 1994";
QTest::newRow("If-Modified-Since-RFC1123") << QNetworkRequest::IfModifiedSinceHeader
<< QVariant(QDateTime(QDate(1994, 8, 06),
QTime(8, 49, 37),
QTimeZone::UTC))
<< true << "If-Modified-Since"
<< "Sun, 06 Aug 1994 08:49:37 GMT";
QTest::newRow("If-Modified-Since-RFC850") << QNetworkRequest::IfModifiedSinceHeader
<< QVariant(QDateTime(QDate(1994, 8, 06),
QTime(8, 49, 37),
QTimeZone::UTC))
<< true << "If-Modified-Since"
<< "Sunday, 06-Aug-94 08:49:37 GMT";
QTest::newRow("If-Modified-Since-asctime") << QNetworkRequest::IfModifiedSinceHeader
<< QVariant(QDateTime(QDate(1994, 8, 06),
QTime(8, 49, 37),
QTimeZone::UTC))
<< true << "If-Modified-Since"
<< "Sun Aug 6 08:49:37 1994";
QTest::newRow("Etag-strong") << QNetworkRequest::ETagHeader << QVariant(R"("xyzzy")")
<< true << "ETag" << R"("xyzzy")";
QTest::newRow("Etag-weak") << QNetworkRequest::ETagHeader << QVariant(R"(W/"xyzzy")")
<< true << "ETag" << R"(W/"xyzzy")";
QTest::newRow("Etag-empty") << QNetworkRequest::ETagHeader << QVariant(R"("")")
<< true << "ETag" << R"("")";
QTest::newRow("If-Match-empty") << QNetworkRequest::IfMatchHeader << QVariant(QStringList(R"("")"))
<< true << "If-Match" << R"("")";
QTest::newRow("If-Match-any") << QNetworkRequest::IfMatchHeader << QVariant(QStringList(R"("*")"))
<< true << "If-Match" << R"("*")";
QTest::newRow("If-Match-single") << QNetworkRequest::IfMatchHeader
<< QVariant(QStringList(R"("xyzzy")"))
<< true << "If-Match" << R"("xyzzy")";
QTest::newRow("If-Match-multiple") << QNetworkRequest::IfMatchHeader
<< QVariant(QStringList({R"("xyzzy")",
R"("r2d2xxxx")",
R"("c3piozzzz")"}))
<< true << "If-Match"
<< R"("xyzzy", "r2d2xxxx", "c3piozzzz")";
QTest::newRow("If-None-Match-empty") << QNetworkRequest::IfNoneMatchHeader
<< QVariant(QStringList(R"("")"))
<< true << "If-None-Match" << R"("")";
QTest::newRow("If-None-Match-any") << QNetworkRequest::IfNoneMatchHeader
<< QVariant(QStringList(R"("*")"))
<< true << "If-None-Match" << R"("*")";
QTest::newRow("If-None-Match-single") << QNetworkRequest::IfNoneMatchHeader
<< QVariant(QStringList(R"("xyzzy")"))
<< true << "If-None-Match" << R"("xyzzy")";
QTest::newRow("If-None-Match-multiple") << QNetworkRequest::IfNoneMatchHeader
<< QVariant(QStringList({R"("xyzzy")",
R"(W/"r2d2xxxx")",
R"("c3piozzzz")"}))
<< true << "If-None-Match"
<< R"("xyzzy", W/"r2d2xxxx", "c3piozzzz")";
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
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Cookie"
<< "a=b";
QTest::newRow("SetCookie-1") << QNetworkRequest::SetCookieHeader
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie)
<< true << "Set-Cookie"
<< "a=b";
cookie.setPath("/");
QTest::newRow("SetCookie-2") << QNetworkRequest::SetCookieHeader
<< QVariant::fromValue(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
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< true << "Cookie"
<< "a=b; c=d";
cookie.setPath("/");
QTest::newRow("SetCookie-3") << QNetworkRequest::SetCookieHeader
<< QVariant::fromValue(QList<QNetworkCookie>() << cookie << cookie2)
<< true << "Set-Cookie"
<< "a=b; path=/\nc=d";
QTest::newRow("Content-Disposition") << QNetworkRequest::ContentDispositionHeader
<< QVariant("attachment; filename=\"test.txt\"") << true
<< "Content-Disposition" << "attachment; filename=\"test.txt\"";
}
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.metaType().id() < QMetaType::User)
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());
}
void tst_QNetworkRequest::setHeaders_data()
{
QTest::addColumn<QHttpHeaders>("h");
QTest::newRow("null") << QHttpHeaders();
QHttpHeaders headers;
headers.append("name1", "value1");
QTest::newRow("valid") << headers;
}
void tst_QNetworkRequest::setHeaders()
{
QFETCH(QHttpHeaders, h);
QNetworkRequest r1;
auto result = r1.headers();
QVERIFY(result.isEmpty());
r1.setHeaders(h);
QCOMPARE(r1.headers().toListOfPairs(), h.toListOfPairs());
QNetworkRequest r2;
auto tmp = h;
r2.setHeaders(std::move(tmp));
QCOMPARE(r2.headers().toListOfPairs(), h.toListOfPairs());
}
void tst_QNetworkRequest::operatorEqual_data()
{
QTest::addColumn<QNetworkRequest>("a");
QTest::addColumn<QNetworkRequest>("b");
QTest::addColumn<bool>("expectedToMatch");
QTest::newRow("null") << QNetworkRequest() << QNetworkRequest() << true;
QNetworkRequest data1;
data1.setUrl(QUrl("http://qt-project.org"));
QTest::newRow("url-1-1") << data1 << QNetworkRequest() << false;
QTest::newRow("url-1-2") << data1 << data1 << true;
QNetworkRequest data2;
QHttpHeaders headers;
headers.append("name1", "value1");
data2.setHeaders(headers);
QTest::newRow("headers-2-1") << data2 << QNetworkRequest() << false;
QTest::newRow("headers-2-2") << data2 << data2 << true;
QTest::newRow("headers-2-3") << data2 << data1 << false;
QNetworkRequest data3;
data3.setPeerVerifyName("peerName");
QTest::newRow("peerName-3-1") << data3 << QNetworkRequest() << false;
QTest::newRow("peerName-3-2") << data3 << data3 << true;
QTest::newRow("peerName-3-3") << data3 << data1 << false;
QTest::newRow("peerName-3-4") << data3 << data2 << false;
QNetworkRequest data4;
data4.setAttribute(QNetworkRequest::Http2AllowedAttribute, true);
QTest::newRow("attribute-4-1") << data4 << QNetworkRequest() << false;
QTest::newRow("attribute-4-2") << data4 << data4 << true;
QTest::newRow("attribute-4-3") << data4 << data1 << false;
QTest::newRow("attribute-4-4") << data4 << data2 << false;
QTest::newRow("attribute-4-5") << data4 << data3 << false;
QNetworkRequest data5;
data5.setPriority(QNetworkRequest::Priority::HighPriority);
QTest::newRow("priority-5-1") << data5 << QNetworkRequest() << false;
QTest::newRow("priority-5-2") << data5 << data5 << true;
QTest::newRow("priority-5-3") << data5 << data1 << false;
QTest::newRow("priority-5-4") << data5 << data2 << false;
QTest::newRow("priority-5-5") << data5 << data3 << false;
QTest::newRow("priority-5-6") << data5 << data4 << false;
QNetworkRequest data6;
data6.setMaximumRedirectsAllowed(3);
QTest::newRow("maxRedirects-6-1") << data6 << QNetworkRequest() << false;
QTest::newRow("maxRedirects-6-2") << data6 << data6 << true;
QTest::newRow("maxRedirects-6-3") << data6 << data1 << false;
QTest::newRow("maxRedirects-6-4") << data6 << data2 << false;
QTest::newRow("maxRedirects-6-5") << data6 << data3 << false;
QTest::newRow("maxRedirects-6-6") << data6 << data4 << false;
QTest::newRow("maxRedirects-6-7") << data6 << data5 << false;
#if QT_CONFIG(http)
QNetworkRequest data7;
QHttp1Configuration http1Configuration;
http1Configuration.setNumberOfConnectionsPerHost(5);
data7.setHttp1Configuration(http1Configuration);
QTest::newRow("http1Config-7-1") << data7 << QNetworkRequest() << false;
QTest::newRow("http1Config-7-2") << data7 << data7 << true;
QTest::newRow("http1Config-7-3") << data7 << data1 << false;
QTest::newRow("http1Config-7-4") << data7 << data2 << false;
QTest::newRow("http1Config-7-5") << data7 << data3 << false;
QTest::newRow("http1Config-7-6") << data7 << data4 << false;
QTest::newRow("http1Config-7-7") << data7 << data5 << false;
QTest::newRow("http1Config-7-8") << data7 << data6 << false;
QNetworkRequest data8;
QHttp2Configuration http2Configuration;
http2Configuration.setMaxFrameSize(16386);
data8.setHttp2Configuration(http2Configuration);
QTest::newRow("http2Config-8-1") << data8 << QNetworkRequest() << false;
QTest::newRow("http2Config-8-2") << data8 << data8 << true;
QTest::newRow("http2Config-8-3") << data8 << data1 << false;
QTest::newRow("http2Config-8-4") << data8 << data2 << false;
QTest::newRow("http2Config-8-5") << data8 << data3 << false;
QTest::newRow("http2Config-8-6") << data8 << data4 << false;
QTest::newRow("http2Config-8-7") << data8 << data5 << false;
QTest::newRow("http2Config-8-8") << data8 << data6 << false;
QTest::newRow("http2Config-8-9") << data8 << data7 << false;
QNetworkRequest data9;
data9.setDecompressedSafetyCheckThreshold(-1);
QTest::newRow("threshold-9-1") << data9 << QNetworkRequest() << false;
QTest::newRow("threshold-9-2") << data9 << data9 << true;
QTest::newRow("threshold-9-3") << data9 << data1 << false;
QTest::newRow("threshold-9-4") << data9 << data2 << false;
QTest::newRow("threshold-9-5") << data9 << data3 << false;
QTest::newRow("threshold-9-6") << data9 << data4 << false;
QTest::newRow("threshold-9-7") << data9 << data5 << false;
QTest::newRow("threshold-9-8") << data9 << data6 << false;
QTest::newRow("threshold-9-9") << data9 << data7 << false;
QTest::newRow("threshold-9-10") << data9 << data8 << false;
#endif
#if QT_CONFIG(http) || defined (Q_OS_WASM)
QNetworkRequest data10;
data10.setTransferTimeout(50000);
QTest::newRow("timeout-10-1") << data10 << QNetworkRequest() << false;
QTest::newRow("timeout-10-2") << data10 << data10 << true;
QTest::newRow("timeout-10-3") << data10 << data1 << false;
QTest::newRow("timeout-10-4") << data10 << data2 << false;
QTest::newRow("timeout-10-5") << data10 << data3 << false;
QTest::newRow("timeout-10-6") << data10 << data4 << false;
QTest::newRow("timeout-10-7") << data10 << data5 << false;
QTest::newRow("timeout-10-8") << data10 << data6 << false;
QTest::newRow("timeout-10-9") << data10 << data7 << false;
QTest::newRow("timeout-10-10") << data10 << data8 << false;
QTest::newRow("timeout-10-11") << data10 << data9 << false;
#endif
}
// public bool operator==(const QNetworkRequest &other) const
void tst_QNetworkRequest::operatorEqual()
{
QFETCH(QNetworkRequest, a);
QFETCH(QNetworkRequest, b);
QFETCH(bool, expectedToMatch);
QCOMPARE(a == b, expectedToMatch);
}
QTEST_MAIN(tst_QNetworkRequest)
#include "tst_qnetworkrequest.moc"