AuthorizationResultPtr OAuth2Response::parseAuthorizeResponse(const String& webAuthenticationResult, CallStatePtr/* callState*/)
{
Logger::info(Tag(), "parseAuthorizeResponse");
Logger::hidden(Tag(), "webAuthenticationResult: " + webAuthenticationResult);
AuthorizationResultPtr parseResult = nullptr;
QUrl url(webAuthenticationResult.data());
if (url.hasQuery())
{
QUrlQuery query = QUrlQuery(url);
if( query.hasQueryItem(OAuthConstants::oAuthReservedClaim().Code.data()) )
{
parseResult = std::make_shared<AuthorizationResult>(query.queryItemValue(OAuthConstants::oAuthReservedClaim().Code.data()).toStdString());
}
else if( query.hasQueryItem(OAuthConstants::oAuthReservedClaim().Error.data()) )
{
String error = query.queryItemValue(OAuthConstants::oAuthReservedClaim().Error.data()).toStdString();
String errorDesc = query.hasQueryItem(OAuthConstants::oAuthReservedClaim().ErrorDescription.data())
? query.queryItemValue(OAuthConstants::oAuthReservedClaim().ErrorDescription.data(), QUrl::FullyDecoded).toStdString()
: "";
parseResult = std::make_shared<AuthorizationResult>(
error,
StringUtils::replaceAll(errorDesc, '+', ' '));
}
else
{
parseResult = std::make_shared<AuthorizationResult>(
Constants::rmsauthError().AuthenticationFailed,
Constants::rmsauthErrorMessage().AuthorizationServerInvalidResponse);
}
}
return parseResult;
}
QJsonObject RequestsManager::autorisation( const SQLMgr &db, const QUrlQuery &urlQuery )
{
UserControl userControl = UserControl::instance();
QString login = urlQuery.queryItemValue( "login" ),
password = urlQuery.queryItemValue( "password" );
if( db.auth( login, password ) )
{
/*db.select( "USERS", { "name", } );*/
User user( login );
QString token = userControl.pushUser( user );
QJsonObject response{
{ "token", token }
};
QJsonObject obj{
{ "code", 200 },
{ "response", response }
};
return obj;
}
QJsonObject failed{
{ "autirisation", "failed" }
};
return failed;
}
CommandLineParameters parseCommandLine(const QStringList &arguments)
{
QCommandLineParser parser;
parser.setApplicationDescription(QObject::tr("Zeal - Offline documentation browser."));
parser.addHelpOption();
parser.addVersionOption();
/// TODO: [Qt 5.4] parser.addOption({{"f", "force"}, "Force the application run."});
parser.addOption(QCommandLineOption({QStringLiteral("f"), QStringLiteral("force")},
QObject::tr("Force the application run.")));
/// TODO: [0.2.0] Remove --query support
parser.addOption(QCommandLineOption({QStringLiteral("q"), QStringLiteral("query")},
QObject::tr("[DEPRECATED] Query <search term>."),
QStringLiteral("term")));
#ifdef Q_OS_WIN32
parser.addOption(QCommandLineOption({QStringLiteral("register")},
QObject::tr("Register protocol handlers")));
parser.addOption(QCommandLineOption({QStringLiteral("unregister")},
QObject::tr("Unregister protocol handlers")));
#endif
parser.addPositionalArgument(QStringLiteral("url"), QObject::tr("dash[-plugin]:// URL"));
parser.process(arguments);
CommandLineParameters clParams;
clParams.force = parser.isSet(QStringLiteral("force"));
#ifdef Q_OS_WIN32
clParams.registerProtocolHandlers = parser.isSet(QStringLiteral("register"));
clParams.unregisterProtocolHandlers = parser.isSet(QStringLiteral("unregister"));
if (clParams.registerProtocolHandlers && clParams.unregisterProtocolHandlers) {
QTextStream(stderr) << QObject::tr("Parameter conflict: --register and --unregister.\n");
::exit(EXIT_FAILURE);
}
#endif
if (parser.isSet(QStringLiteral("query"))) {
clParams.query.setQuery(parser.value(QStringLiteral("query")));
} else {
/// TODO: Support dash-feed:// protocol
const QString arg
= QUrl::fromPercentEncoding(parser.positionalArguments().value(0).toUtf8());
if (arg.startsWith(QLatin1String("dash:"))) {
clParams.query.setQuery(stripParameterUrl(arg, QStringLiteral("dash")));
} else if (arg.startsWith(QLatin1String("dash-plugin:"))) {
const QUrlQuery urlQuery(stripParameterUrl(arg, QStringLiteral("dash-plugin")));
const QString keys = urlQuery.queryItemValue(QStringLiteral("keys"));
if (!keys.isEmpty())
clParams.query.setKeywords(keys.split(QLatin1Char(',')));
clParams.query.setQuery(urlQuery.queryItemValue(QStringLiteral("query")));
} else {
clParams.query.setQuery(arg);
}
}
return clParams;
}
void tst_QUrlQuery::multiAddRemove()
{
QUrlQuery query;
{
// one item, two values
query.addQueryItem("a", "b");
query.addQueryItem("a", "c");
QVERIFY(!query.isEmpty());
QVERIFY(query.hasQueryItem("a"));
// returns the first one
QVERIFY(query.queryItemValue("a") == "b");
// order is the order we set them in
QVERIFY(query.allQueryItemValues("a") == QStringList() << "b" << "c");
}
{
// add another item, two values
query.addQueryItem("A", "B");
query.addQueryItem("A", "C");
QVERIFY(query.hasQueryItem("A"));
QVERIFY(query.hasQueryItem("a"));
QVERIFY(query.queryItemValue("a") == "b");
QVERIFY(query.allQueryItemValues("a") == QStringList() << "b" << "c");
QVERIFY(query.queryItemValue("A") == "B");
QVERIFY(query.allQueryItemValues("A") == QStringList() << "B" << "C");
}
{
// remove one of the original items
query.removeQueryItem("a");
QVERIFY(query.hasQueryItem("a"));
// it must have removed the first one
QVERIFY(query.queryItemValue("a") == "c");
}
{
// remove the items we added later
query.removeAllQueryItems("A");
QVERIFY(!query.isEmpty());
QVERIFY(!query.hasQueryItem("A"));
}
{
// add one element to the current, then remove them
query.addQueryItem("a", "d");
query.removeAllQueryItems("a");
QVERIFY(!query.hasQueryItem("a"));
QVERIFY(query.isEmpty());
}
}
void Utils::testIncludeUrlParams() {
QUrl urla(QString("http://example.com"));
QHash<QString, QString> params;
params.insert("simple", "c");
params.insert("withspecial", "a?b");
params.insert("withspace", "a b");
params.insert("username", "a123fx b");
params.insert("password", "!@#+-$%^12&*()qweqesaf\"';`~");
params.insert("withplus", "a+b");
QUrl urlb = ::includeQueryParams(urla, params);
QVERIFY(urla.scheme() == urlb.scheme());
QVERIFY(urla.host() == urlb.host());
Q_FOREACH (const QString& key, params.keys()) {
#if (QT_VERSION >= QT_VERSION_CHECK(5, 0, 0))
QString encoded_key = QUrl::toPercentEncoding(key);
QString encoded_value = QUrl::toPercentEncoding(params[encoded_key]);
QUrlQuery query = QUrlQuery(urlb.query());
QVERIFY(query.queryItemValue(encoded_key, QUrl::FullyEncoded) == encoded_value);
#else
QVERIFY(urlb.queryItemValue(key) == params[key]);
#endif
}
}
void OpenLinksFromFileSystem::AnchorClicked(const QUrl & url)
{
#ifdef Q_OS_WIN
if(url.host().contains("shelexecute"))
{
QUrlQuery q;
q.setQuery(url.query());
QString cmd = q.queryItemValue("cmd",QUrl::FullyDecoded);
QString arg = q.queryItemValue("arg",QUrl::FullyDecoded);
LPCWSTR s1 = (LPCWSTR)cmd.utf16();
LPCWSTR s2 = NULL;
if(q.hasQueryItem("arg"))
s2 = (LPCWSTR)arg.utf16();
ShellExecute(NULL,NULL,s1,s2,NULL,SW_RESTORE);
}else
#endif
{
QFileInfo info(url.toString());
QDesktopServices::openUrl(QUrl::fromLocalFile(info.absoluteFilePath()));
}
}
/*!
* Image {
* source: "image://avatar/path?name=icon-name"
* }
*
* Image {
* source: "image://avatar/path?size=64&name=icon-name"
* }
*/
QPixmap QuickAvatarProvider::requestPixmap(const QString &id, QSize *size, const QSize &requestedSize)
{
const QUrl url(QStringLiteral("file:///") + id);
const QUrlQuery query(url.query());
const QString filePath = url.path();
const QString iconName = query.queryItemValue(QStringLiteral("name"));
const QString iconSize = query.queryItemValue(QStringLiteral("size"));
QSize tmp;
if (!size)
size = &tmp;
bool ok = false;
int iconSizeValue = iconSize.toInt(&ok);
if (ok)
*size = QSize(iconSizeValue, iconSizeValue);
else if (requestedSize.width() > 0)
*size = requestedSize;
else
*size = QSize(128, 128);
QIcon icon = Icon(iconName);
if (filePath.size() > 1)
icon = AvatarFilter::icon(filePath, icon);
return icon.pixmap(*size);
}
void tst_QUrlQuery::old_queryItems()
{
// test imported from old tst_qurl.cpp
QUrlQuery url;
QList<QPair<QString, QString> > newItems;
newItems += qMakePair(QString("1"), QString("a"));
newItems += qMakePair(QString("2"), QString("b"));
newItems += qMakePair(QString("3"), QString("c"));
newItems += qMakePair(QString("4"), QString("a b"));
newItems += qMakePair(QString("5"), QString("&"));
newItems += qMakePair(QString("foo bar"), QString("hello world"));
newItems += qMakePair(QString("foo+bar"), QString("hello+world"));
newItems += qMakePair(QString("tex"), QString("a + b = c"));
url.setQueryItems(newItems);
QVERIFY(!url.isEmpty());
QList<QPair<QString, QString> > setItems = url.queryItems();
QVERIFY(newItems == setItems);
url.addQueryItem("1", "z");
#if 0
// undefined behaviour in the new QUrlQuery
QVERIFY(url.hasQueryItem("1"));
QCOMPARE(url.queryItemValue("1").toLatin1().constData(), "a");
url.addQueryItem("1", "zz");
QStringList expected;
expected += "a";
expected += "z";
expected += "zz";
QCOMPARE(url.allQueryItemValues("1"), expected);
url.removeQueryItem("1");
QCOMPARE(url.allQueryItemValues("1").size(), 2);
QCOMPARE(url.queryItemValue("1").toLatin1().constData(), "z");
#endif
url.removeAllQueryItems("1");
QVERIFY(!url.hasQueryItem("1"));
QCOMPARE(url.queryItemValue("4").toLatin1().constData(), "a b");
QCOMPARE(url.queryItemValue("5").toLatin1().constData(), "&");
QCOMPARE(url.queryItemValue("tex").toLatin1().constData(), "a + b = c");
QCOMPARE(url.queryItemValue("foo bar").toLatin1().constData(), "hello world");
//url.setUrl("http://www.google.com/search?q=a+b");
url.setQuery("q=a+b");
QCOMPARE(url.queryItemValue("q"), QString("a+b"));
//url.setUrl("http://www.google.com/search?q=a=b"); // invalid, but should be tolerated
url.setQuery("q=a=b");
QCOMPARE(url.queryItemValue("q"), QString("a=b"));
}
void TestAwsSignatureV2::adornRequest()
{
QFETCH(QNetworkRequest, request);
QFETCH(QString, accessKeyId);
QFETCH(QCryptographicHash::Algorithm, algorithm);
QFETCH(QString, signatureMethod);
const AwsBasicCredentials credentials(accessKeyId, QString());
AwsSignatureV2 signature(algorithm);
signature.d_func()->adornRequest(request, credentials);
const QUrlQuery query(request.url());
QVERIFY(query.hasQueryItem(QLatin1String("AWSAccessKeyId")));
QVERIFY(query.hasQueryItem(QLatin1String("SignatureMethod")));
QVERIFY(query.hasQueryItem(QLatin1String("SignatureVersion")));
QVERIFY(query.hasQueryItem(QLatin1String("Timestamp")));
QCOMPARE(query.queryItemValue(QLatin1String("AWSAccessKeyId")), accessKeyId);
QCOMPARE(query.queryItemValue(QLatin1String("SignatureMethod")), signatureMethod);
QCOMPARE(query.queryItemValue(QLatin1String("SignatureVersion")), QString::fromLatin1("2"));
}
QJsonObject RequestsManager::report( const SQLMgr &db, const QString &request, const QUrlQuery &query )
{
IdTitleMap List;
QJsonObject obj;
if( request.startsWith( "/get" ) ) // /getProfessionsLIst
{
QString listName = request.right( 4 );
List = listName.startsWith( "lesson", Qt::CaseInsensitive ) ? // íàâåðíîå ýòî óæàñíî ÷èòàåòñÿ, íî ðàîòàåò
Lesson::getLessonsList( db, query.queryItemValue( "id" ) ) :
listName.startsWith( "prof", Qt::CaseInsensitive ) ?
Profession::getProfList( db ) :
listName.startsWith( "theme", Qt::CaseInsensitive ) ?
Theme::getThemeList( db, query.queryItemValue( "id" ) ) :
IdTitleMap();
obj = JsonFormat::lessonsListToJsonObj( List );
}
//TODO TcpSocket::report( obj );
return obj;
}
int SM_QDropbox::requestAccessToken(bool blocking)
{
clearError();
QUrl url;
url.setUrl(apiurl.toString());
QUrlQuery query;
query.addQueryItem("oauth_consumer_key",_appKey);
query.addQueryItem("oauth_nonce", nonce);
query.addQueryItem("oauth_signature_method", signatureMethodString());
query.addQueryItem("oauth_timestamp", QString::number(timestamp));
query.addQueryItem("oauth_token", oauthToken);
query.addQueryItem("oauth_version", _version);
url.setPath(QString("/%1/oauth/access_token").
arg(_version.left(1)));
#ifdef SM_QTDROPBOX_DEBUG
qDebug() << "requestToken = " << query.queryItemValue("oauth_token");
#endif
QString signature = oAuthSign(url);
query.addQueryItem("oauth_signature", QUrl::toPercentEncoding(signature));
url.setQuery(query);
QString dataString = url.toString(QUrl::RemoveScheme|QUrl::RemoveAuthority|
QUrl::RemovePath).mid(1);
#ifdef SM_QTDROPBOX_DEBUG
qDebug() << "dataString = " << dataString << endl;
#endif
QByteArray postData;
postData.append(dataString.toUtf8());
QUrl xQuery(url.toString(QUrl::RemoveQuery));
int reqnr = sendRequest(xQuery, "POST", postData);
if(blocking)
{
requestMap[reqnr].type = SM_DROPBOX_REQ_BACCTOK;
startEventLoop();
}
else
requestMap[reqnr].type = SM_DROPBOX_REQ_ACCTOKN;
return reqnr;
}
bool VkAuthManager::CheckReply (QUrl location)
{
if (location.path () != "/blank.html")
return CheckError (location);
location = QUrl::fromEncoded (location.toEncoded ().replace ('#', '?'));
#if QT_VERSION < 0x050000
Token_ = location.queryItemValue ("access_token");
ValidFor_ = location.queryItemValue ("expires_in").toInt ();
#else
const QUrlQuery query { location };
Token_ = query.queryItemValue ("access_token");
ValidFor_ = query.queryItemValue ("expires_in").toInt ();
#endif
ReceivedAt_ = QDateTime::currentDateTime ();
qDebug () << Q_FUNC_INFO << Token_ << ValidFor_;
IsRequesting_ = false;
InvokeQueues (Token_);
emit gotAuthKey (Token_);
emit justAuthenticated ();
return true;
}
/**
* @brief Set a query item, checking for existing values first.
*
* This function is a light wrapper around QUrlQuery::addQueryItem() that first
* checks for existing values. Existing values will not be overwritten, instead
* if existing values are found, this function will simply check if the exsting
* value matches the desired \a value, and if not, will return `false` and
* optionally (according to \a warnOnNonIdenticalDuplicate) issue a qWarning().
*
* Typically, when setting something that must be a specific value, such as an
* access key ID, \a warnOnNonIdenticalDuplicate would be `true`. However, when
* setting query items as a fall-back default, such as a current timestamp,
* \a warnOnNonIdenticalDuplicate would typically be set to `false`.
*
* @param query URL query to add the query item to.
* @param key Query item key to add to \a query.
* @param value Query item value to add to \a query.
* @param warnOnNonIdenticalDuplicate If `true`, and an exisiting \a key
* value is found in \a query that has a value other than \a value,
* then a qWarning() is issued, otherwise the duplicate is silently
* ignored.
*
* @return `true` if the query item was set successfully or was already set to
* the requested value previously, `false` otherwise.
*/
bool AwsAbstractSignaturePrivate::setQueryItem(QUrlQuery &query, const QString &key, const QString &value,
const bool warnOnNonIdenticalDuplicate) const
{
if (query.hasQueryItem(key)) {
const QString existingValue = query.queryItemValue(key, QUrl::FullyEncoded);
const bool existingQueryItemIsIdentical = (existingValue == value);
if ((warnOnNonIdenticalDuplicate) && (!existingQueryItemIsIdentical)) {
qWarning() << "AwsAbstractSignature::setQueryItem Not overwriting existing value for key"
<< key << ':' << existingValue;
}
return existingQueryItemIsIdentical;
}
query.addQueryItem(key, value);
return true;
}
QQuickWebEngineView *GameUpQtPrivate::webView() const {
#else
QQuickWebView *GameUpQt::webView() const {
#endif
return m_webView;
}
#ifdef QT_WEBVIEW_WEBENGINE_BACKEND
void GameUpQtPrivate::setWebView(QQuickWebEngineView *webView) {
#else
void GameUpQtPrivate::setWebView(QQuickWebView *webView) {
#endif
m_webView = webView;
}
Gamer *GameUpQtPrivate::getGamer() {
return &m_gamer;
}
QString GameUpQtPrivate::getLeaderboardID() const {
return m_leaderboardID;
}
void GameUpQtPrivate::setLeaderboardID(const QString &leaderboardID) {
m_leaderboardID = leaderboardID;
}
Leaderboard *GameUpQtPrivate::getLeaderboard(const QString &id) {
return m_leaderboards[id];
}
bool GameUpQtPrivate::getAsyncMode() const {
return m_asyncMode;
}
void GameUpQtPrivate::setAsyncMode(bool asyncMode) {
m_asyncMode = asyncMode;
}
QNetworkReply::NetworkError GameUpQtPrivate::getLasterror() const {
return lasterror;
}
QString GameUpQtPrivate::getLastToken() const {
return m_lastToken;
}
QQmlListProperty<Leaderboard> GameUpQtPrivate::leaderboards() {
QList<Leaderboard*> l = m_leaderboards.values();
return QQmlListProperty<Leaderboard>(this, l);
}
#ifdef QT_WEBVIEW_WEBENGINE_BACKEND
void GameUpQtPrivate::webViewLoadingProgress(QQuickWebEngineLoadRequest *loadRequest) {
qDebug() << "loadrequest" << loadRequest->url() << loadRequest->errorCode() << loadRequest->status();
QUrlQuery query = QUrlQuery(loadRequest->url());
if (query.hasQueryItem("token")) {
m_lastToken = query.queryItemValue("token");
}
if (!m_lastToken.isEmpty()
|| loadRequest->errorCode() != 0
|| loadRequest->status() == QQuickWebEngineView::LoadFailedStatus
|| query.isEmpty()) {
disconnect(m_webView, &QQuickWebEngineView::loadingChanged, this, &GameUpQtPrivate::webViewLoadingProgress);
if (!m_asyncMode && loop.isRunning())
loop.quit();
emit reqComplete(GameUpQt::Login);
}
}
bool WulforUtil::openUrl(const QString &url){
if (url.startsWith("http://") || url.startsWith("www.") || url.startsWith(("ftp://")) || url.startsWith("https://")){
if (!SETTING(MIME_HANDLER).empty())
QProcess::startDetached(_q(SETTING(MIME_HANDLER)), QStringList(url));
else
QDesktopServices::openUrl(QUrl::fromEncoded(url.toUtf8()));
}
else if (url.startsWith("adc://") || url.startsWith("adcs://")){
MainWindow::getInstance()->newHubFrame(url, "UTF-8");
}
else if (url.startsWith("dchub://") || url.startsWith("nmdcs://")){
MainWindow::getInstance()->newHubFrame(url, WSGET(WS_DEFAULT_LOCALE));
}
else if (url.startsWith("magnet:") && url.contains("urn:tree:tiger")){
QString magnet = url;
Magnet *m = new Magnet(MainWindow::getInstance());
m->setLink(magnet);
m->exec();
m->deleteLater();
}
else if (url.startsWith("magnet:")){
const QString magnet = url;
#if QT_VERSION >= 0x050000
QUrlQuery u;
#else
QUrl u;
#endif
if (!magnet.contains("+")) {
#if QT_VERSION >= 0x050000
u.setQuery(magnet.toUtf8());
#else
u.setEncodedUrl(magnet.toUtf8());
#endif
} else {
QString _l = magnet;
_l.replace("+", "%20");
#if QT_VERSION >= 0x050000
u.setQuery(_l.toUtf8());
#else
u.setEncodedUrl(_l.toUtf8());
#endif
}
if (u.hasQueryItem("kt")) {
QString keywords = u.queryItemValue("kt");
QString hub = u.hasQueryItem("xs")? u.queryItemValue("xs") : "";
if (!(hub.startsWith("dchub://", Qt::CaseInsensitive) ||
hub.startsWith("nmdcs://", Qt::CaseInsensitive) ||
hub.startsWith("adc://", Qt::CaseInsensitive) ||
hub.startsWith("adcs://", Qt::CaseInsensitive)) && !hub.isEmpty())
hub.prepend("dchub://");
if (keywords.isEmpty())
return false;
if (!hub.isEmpty())
WulforUtil::openUrl(hub);
SearchFrame *sfr = ArenaWidgetFactory().create<SearchFrame>();
sfr->fastSearch(keywords, false);
}
else {
if (!SETTING(MIME_HANDLER).empty())
QProcess::startDetached(_q(SETTING(MIME_HANDLER)), QStringList(url));
else
QDesktopServices::openUrl(QUrl::fromEncoded(url.toUtf8()));
}
}
else
return false;
return true;
}
void tst_QUrlQuery::constructing()
{
QUrlQuery empty;
QVERIFY(empty.isEmpty());
QCOMPARE(empty.queryPairDelimiter(), QUrlQuery::defaultQueryPairDelimiter());
QCOMPARE(empty.queryValueDelimiter(), QUrlQuery::defaultQueryValueDelimiter());
// undefined whether it is detached, but don't crash
QVERIFY(empty.isDetached() || !empty.isDetached());
empty.clear();
QVERIFY(empty.isEmpty());
{
QUrlQuery copy(empty);
QVERIFY(copy.isEmpty());
QVERIFY(!copy.isDetached());
QVERIFY(copy == empty);
QVERIFY(!(copy != empty));
copy = empty;
QVERIFY(copy == empty);
copy = QUrlQuery();
QVERIFY(copy == empty);
}
{
QUrlQuery copy(emptyQuery());
QVERIFY(copy == empty);
}
QVERIFY(!empty.hasQueryItem("a"));
QVERIFY(empty.queryItemValue("a").isEmpty());
QVERIFY(empty.allQueryItemValues("a").isEmpty());
QVERIFY(!empty.hasQueryItem(""));
QVERIFY(empty.queryItemValue("").isEmpty());
QVERIFY(empty.allQueryItemValues("").isEmpty());
QVERIFY(!empty.hasQueryItem(QString()));
QVERIFY(empty.queryItemValue(QString()).isEmpty());
QVERIFY(empty.allQueryItemValues(QString()).isEmpty());
QVERIFY(empty.queryItems().isEmpty());
QUrlQuery other;
other.addQueryItem("a", "b");
QVERIFY(!other.isEmpty());
QVERIFY(other.isDetached());
QVERIFY(other != empty);
QVERIFY(!(other == empty));
QUrlQuery copy(other);
QVERIFY(copy == other);
copy.clear();
QVERIFY(copy.isEmpty());
QVERIFY(copy != other);
copy = other;
QVERIFY(!copy.isEmpty());
QVERIFY(copy == other);
copy = QUrlQuery();
QVERIFY(copy.isEmpty());
empty.setQueryDelimiters('(', ')');
QCOMPARE(empty.queryValueDelimiter(), QChar(QLatin1Char('(')));
QCOMPARE(empty.queryPairDelimiter(), QChar(QLatin1Char(')')));
QList<QPair<QString, QString> > query;
query += qMakePair(QString("type"), QString("login"));
query += qMakePair(QString("name"), QString::fromUtf8("åge nissemannsen"));
query += qMakePair(QString("ole&du"), QString::fromUtf8("anne+jørgen=sant"));
query += qMakePair(QString("prosent"), QString("%"));
copy.setQueryItems(query);
QVERIFY(!copy.isEmpty());
}
void tst_QUrlQuery::addRemove()
{
QUrlQuery query;
{
// one item
query.addQueryItem("a", "b");
QVERIFY(!query.isEmpty());
QVERIFY(query.hasQueryItem("a"));
QCOMPARE(query.queryItemValue("a"), QString("b"));
QCOMPARE(query.allQueryItemValues("a"), QStringList() << "b");
QList<QPair<QString, QString> > allItems = query.queryItems();
QCOMPARE(allItems.count(), 1);
QCOMPARE(allItems.at(0).first, QString("a"));
QCOMPARE(allItems.at(0).second, QString("b"));
}
QUrlQuery original = query;
{
// two items
query.addQueryItem("c", "d");
QVERIFY(query.hasQueryItem("a"));
QCOMPARE(query.queryItemValue("a"), QString("b"));
QCOMPARE(query.allQueryItemValues("a"), QStringList() << "b");
QVERIFY(query.hasQueryItem("c"));
QCOMPARE(query.queryItemValue("c"), QString("d"));
QCOMPARE(query.allQueryItemValues("c"), QStringList() << "d");
QList<QPair<QString, QString> > allItems = query.queryItems();
QCOMPARE(allItems.count(), 2);
QVERIFY(allItems.contains(qItem("a", "b")));
QVERIFY(allItems.contains(qItem("c", "d")));
QVERIFY(query != original);
QVERIFY(!(query == original));
}
{
// remove an item that isn't there
QUrlQuery copy = query;
query.removeQueryItem("e");
QCOMPARE(query, copy);
}
{
// remove an item
query.removeQueryItem("c");
QVERIFY(query.hasQueryItem("a"));
QCOMPARE(query.queryItemValue("a"), QString("b"));
QCOMPARE(query.allQueryItemValues("a"), QStringList() << "b");
QList<QPair<QString, QString> > allItems = query.queryItems();
QCOMPARE(allItems.count(), 1);
QCOMPARE(allItems.at(0).first, QString("a"));
QCOMPARE(allItems.at(0).second, QString("b"));
QVERIFY(query == original);
QVERIFY(!(query != original));
}
{
// add an item with en empty value
QString emptyButNotNull(0, Qt::Uninitialized);
QVERIFY(emptyButNotNull.isEmpty());
QVERIFY(!emptyButNotNull.isNull());
query.addQueryItem("e", "");
QVERIFY(query.hasQueryItem("a"));
QCOMPARE(query.queryItemValue("a"), QString("b"));
QCOMPARE(query.allQueryItemValues("a"), QStringList() << "b");
QVERIFY(query.hasQueryItem("e"));
QCOMPARE(query.queryItemValue("e"), emptyButNotNull);
QCOMPARE(query.allQueryItemValues("e"), QStringList() << emptyButNotNull);
QList<QPair<QString, QString> > allItems = query.queryItems();
QCOMPARE(allItems.count(), 2);
QVERIFY(allItems.contains(qItem("a", "b")));
QVERIFY(allItems.contains(qItem("e", emptyButNotNull)));
QVERIFY(query != original);
QVERIFY(!(query == original));
}
{
// remove the items
query.removeQueryItem("a");
query.removeQueryItem("e");
QVERIFY(query.isEmpty());
}
}
