Change the component formatting enum values so the default is zero

By having the default value equal to zero, we follow the principle of
least surprise. For example, if we had
      url.path()
and we refactored to
      url.path(QUrl::DecodeSpaces)

Then instead of ensuring spaces are decoded, we make spaces the only
thing encoded (unicode, delimiters and reserved characters are
encoded).

Besides, modifying the default can only be used to encode something
that wasn't encoded previously, so having the enums as Encode makes
more sense.

As a side-effect, toEncoded() does not support any extra encoding
options.

Change-Id: I2624ec446e65c2d979e9ca2f81bd3db22b00bb13
Reviewed-by: Shane Kearns <shane.kearns@accenture.com>

8 files changed, 111 insertions, 76 deletions

diff --git a/src/corelib/io/qurl.cpp b/src/corelib/io/qurl.cpp
index cbe39e9fdf..44d5533364 100644
--- a/src/corelib/io/qurl.cpp
+++ b/src/corelib/io/qurl.cpp
@@ -467,16 +467,16 @@ static inline void appendToUser(QString &appendTo, const QString &value, QUrl::F
     }
 
     const ushort *actions = 0;
-    if (options & QUrl::DecodeDelimiters)
-        actions = decodedActions;
-    else
+    if (options & QUrl::EncodeDelimiters)
         actions = encodedActions;
+    else
+        actions = decodedActions;
 
     if (!qt_urlRecode(appendTo, value.constData(), value.constEnd(), options, actions))
         appendTo += value;
 }
 
-void QUrlPrivate::appendAuthority(QString &appendTo, QUrl::FormattingOptions options, Section appendingTo) const
+inline void QUrlPrivate::appendAuthority(QString &appendTo, QUrl::FormattingOptions options, Section appendingTo) const
 {
     if ((options & QUrl::RemoveUserInfo) != QUrl::RemoveUserInfo) {
         appendUserInfo(appendTo, options, appendingTo);
@@ -488,14 +488,17 @@ void QUrlPrivate::appendAuthority(QString &appendTo, QUrl::FormattingOptions opt
         appendTo += QLatin1Char(':') + QString::number(port);
 }
 
-void QUrlPrivate::appendUserInfo(QString &appendTo, QUrl::FormattingOptions options, Section appendingTo) const
+inline void QUrlPrivate::appendUserInfo(QString &appendTo, QUrl::FormattingOptions options, Section appendingTo) const
 {
     if (Q_LIKELY(userName.isEmpty() && password.isEmpty()))
         return;
 
     const ushort *userNameActions;
     const ushort *passwordActions;
-    if (options & QUrl::DecodeDelimiters) {
+    if (options & QUrl::EncodeDelimiters) {
+        userNameActions = encodedUserNameActions;
+        passwordActions = encodedPasswordActions;
+    } else {
         switch (appendingTo) {
         case UserInfo:
             userNameActions = decodedUserNameInUserInfoActions;
@@ -513,11 +516,11 @@ void QUrlPrivate::appendUserInfo(QString &appendTo, QUrl::FormattingOptions opti
             passwordActions = decodedPasswordInUrlActions;
             break;
         }
-    } else {
-        userNameActions = encodedUserNameActions;
-        passwordActions = encodedPasswordActions;
     }
 
+    if ((options & QUrl::EncodeReserved) == 0)
+        options |= QUrl::DecodeReserved;
+
     if (!qt_urlRecode(appendTo, userName.constData(), userName.constEnd(), options, userNameActions))
         appendTo += userName;
     if (options & QUrl::RemovePassword || !hasPassword()) {
@@ -541,7 +544,7 @@ inline void QUrlPrivate::appendPassword(QString &appendTo, QUrl::FormattingOptio
 
 inline void QUrlPrivate::appendPath(QString &appendTo, QUrl::FormattingOptions options, Section appendingTo) const
 {
-    if (appendingTo != Path && options & QUrl::DecodeDelimiters) {
+    if (appendingTo != Path && !(options & QUrl::EncodeDelimiters)) {
         if (!qt_urlRecode(appendTo, path.constData(), path.constEnd(), options, decodedPathInUrlActions))
             appendTo += path;
 
@@ -565,12 +568,12 @@ inline void QUrlPrivate::appendQuery(QString &appendTo, QUrl::FormattingOptions
     }
 
     const ushort *actions = 0;
-    if (options & QUrl::DecodeDelimiters) {
+    if (options & QUrl::EncodeDelimiters) {
+        actions = encodedQueryActions;
+    } else {
         // reset to default qt_urlRecode behaviour (leave delimiters alone)
-        options &= ~QUrl::DecodeDelimiters;
+        options |= QUrl::EncodeDelimiters;
         actions = appendingTo == Query ? decodedQueryInIsolationActions : decodedQueryInUrlActions;
-    } else if ((options & QUrl::DecodeDelimiters) == 0) {
-        actions = encodedQueryActions;
     }
 
     if (!qt_urlRecode(appendTo, query.constData(), query.constData() + query.length(),
@@ -764,7 +767,9 @@ inline void QUrlPrivate::setQuery(const QString &value, int from, int iend)
     QString output;
     const QChar *begin = value.constData() + from;
     const QChar *end = value.constData() + iend;
-    if (qt_urlRecode(output, begin, end, QUrl::DecodeUnicode | QUrl::DecodeSpaces,
+
+    // leave delimiters alone but decode the rest
+    if (qt_urlRecode(output, begin, end, QUrl::EncodeDelimiters,
                      decodedQueryInIsolationActions))
         query = output;
     else
@@ -804,7 +809,7 @@ inline void QUrlPrivate::setQuery(const QString &value, int from, int iend)
 inline void QUrlPrivate::appendHost(QString &appendTo, QUrl::FormattingOptions options) const
 {
     // this is the only flag that matters
-    options &= QUrl::DecodeUnicode;
+    options &= QUrl::EncodeUnicode;
     if (host.isEmpty())
         return;
     if (host.at(0).unicode() == '[') {
@@ -813,10 +818,10 @@ inline void QUrlPrivate::appendHost(QString &appendTo, QUrl::FormattingOptions o
     } else {
         // this is either an IPv4Address or a reg-name
         // if it is a reg-name, it is already stored in Unicode form
-        if (options == QUrl::DecodeUnicode)
-            appendTo += host;
-        else
+        if (options == QUrl::EncodeUnicode)
             appendTo += qt_ACE_do(host, ToAceOnly);
+        else
+            appendTo += host;
     }
 }
 
@@ -1915,7 +1920,7 @@ bool QUrl::hasFragment() const
 QString QUrl::topLevelDomain(ComponentFormattingOptions options) const
 {
     QString tld = qTopLevelDomain(host());
-    if ((options & DecodeUnicode) == 0) {
+    if (options & EncodeUnicode) {
         return qt_ACE_do(tld, ToAceOnly);
     }
     return tld;
@@ -2055,8 +2060,12 @@ QString QUrl::toString(FormattingOptions options) const
     }
 
     QString url;
-    if (!options.testFlag(DecodeReserved))
-        options &= ~DecodeReserved;
+
+    // for the full URL, we consider that the reserved characters are prettier if encoded
+    if (options & DecodeReserved)
+        options &= ~EncodeReserved;
+    else
+        options |= EncodeReserved;
 
     if (!(options & QUrl::RemoveScheme) && d->hasScheme())
         url += d->scheme + QLatin1Char(':');
@@ -2123,9 +2132,8 @@ QString QUrl::toDisplayString(FormattingOptions options) const
 */
 QByteArray QUrl::toEncoded(FormattingOptions options) const
 {
-    QString stringForm = toString(options);
-    if (options & DecodeUnicode)
-        return stringForm.toUtf8();
+    options &= ~DecodeReserved;
+    QString stringForm = toString(options | FullyEncoded);
     return stringForm.toLatin1();
 }
 
diff --git a/src/corelib/io/qurl.h b/src/corelib/io/qurl.h
index ff46a8ac1a..dbfc327caf 100644
--- a/src/corelib/io/qurl.h
+++ b/src/corelib/io/qurl.h
@@ -138,15 +138,15 @@ public:
     };
 
     enum ComponentFormattingOption {
-        FullyEncoded = 0x000000,
-        DecodeSpaces = 0x100000,
-        DecodeUnicode = 0x200000,
-        DecodeDelimiters = 0x400000 | 0x800000,
-        PrettyDecodeReserved = 0x1000000,
-        DecodeReserved = PrettyDecodeReserved | 0x2000000,
-
-        PrettyDecoded = DecodeSpaces | DecodeDelimiters | PrettyDecodeReserved | DecodeUnicode,
-        MostDecoded = PrettyDecoded
+        PrettyDecoded = 0x000000,
+        EncodeSpaces = 0x100000,
+        EncodeUnicode = 0x200000,
+        EncodeDelimiters = 0x400000 | 0x800000,
+        EncodeReserved = 0x1000000,
+        DecodeReserved = 0x2000000,
+
+        FullyEncoded = EncodeSpaces | EncodeUnicode | EncodeDelimiters | EncodeReserved,
+        MostDecoded = PrettyDecoded | DecodeReserved
     };
     Q_DECLARE_FLAGS(ComponentFormattingOptions, ComponentFormattingOption)
 #ifdef qdoc
@@ -331,8 +331,6 @@ inline QIncompatibleFlag operator|(QUrl::UrlFormattingOption f1, int f2)
 { return QIncompatibleFlag(int(f1) | f2); }
 
 // add operators for OR'ing the two types of flags
-inline QUrl::FormattingOptions &operator|=(QUrl::FormattingOptions &i, QUrl::ComponentFormattingOption f)
-{ i |= QUrl::UrlFormattingOption(int(f)); return i; }
 inline QUrl::FormattingOptions &operator|=(QUrl::FormattingOptions &i, QUrl::ComponentFormattingOptions f)
 { i |= QUrl::UrlFormattingOption(int(f)); return i; }
 Q_DECL_CONSTEXPR inline QUrl::FormattingOptions operator|(QUrl::UrlFormattingOption i, QUrl::ComponentFormattingOption f)
diff --git a/src/corelib/io/qurlquery.cpp b/src/corelib/io/qurlquery.cpp
index c0b90dd587..ccb03611f5 100644
--- a/src/corelib/io/qurlquery.cpp
+++ b/src/corelib/io/qurlquery.cpp
@@ -226,7 +226,7 @@ inline QString QUrlQueryPrivate::recodeToUser(const QString &input, QUrl::Compon
     if (idempotentRecodeToUser(encoding))
         return input;
 
-    if (encoding & QUrl::DecodeDelimiters) {
+    if (!(encoding & QUrl::EncodeDelimiters)) {
         QString output;
         if (qt_urlRecode(output, input.constData(), input.constData() + input.length(),
                          encoding, prettyDecodedActions))
@@ -466,10 +466,7 @@ QString QUrlQuery::query(QUrl::ComponentFormattingOptions encoding) const
         decode('#'),                         // 3
         0
     };
-    if (encoding & QUrl::DecodeDelimiters) {
-        // full decoding: we only encode the characters above
-        tableActions[3] = 0;
-    } else {
+    if (encoding & QUrl::EncodeDelimiters) {
         tableActions[3] = encode('#');
     }
 
diff --git a/src/corelib/io/qurlrecode.cpp b/src/corelib/io/qurlrecode.cpp
index 02fced5b7b..b586bd7a1e 100644
--- a/src/corelib/io/qurlrecode.cpp
+++ b/src/corelib/io/qurlrecode.cpp
@@ -512,7 +512,7 @@ non_trivial:
 
             if (decoded >= 0x80) {
                 // decode the UTF-8 sequence
-                if (encoding & QUrl::DecodeUnicode &&
+                if (!(encoding & QUrl::EncodeUnicode) &&
                         encodedUtf8ToUtf16(result, output, begin, input, end, decoded))
                     continue;
 
@@ -523,7 +523,7 @@ non_trivial:
             }
         } else {
             decoded = c;
-            if (decoded >= 0x80 && (encoding & QUrl::DecodeUnicode) == 0) {
+            if (decoded >= 0x80 && encoding & QUrl::EncodeUnicode) {
                 // encode the UTF-8 sequence
                 unicodeToEncodedUtf8(result, output, begin, input, end, decoded);
                 continue;
@@ -581,15 +581,42 @@ static void maskTable(uchar (&table)[N], const uchar (&mask)[N])
         table[i] &= mask[i];
 }
 
+/*!
+    \internal
+
+    Recodes the string from \a begin to \a end. If any transformations are
+    done, append them to \a appendTo and return the number of characters added.
+    If no transformations were required, return 0.
+
+    The \a encoding option modifies the default behaviour:
+    \list
+    \li QUrl::EncodeDelimiters: if set, delimiters will be left untransformed (note: not encoded!);
+                                if unset, delimiters will be decoded
+    \li QUrl::DecodeReserved: if set, reserved characters will be decoded;
+                              if unset, reserved characters will be encoded
+    \li QUrl::EncodeSpaces: if set, spaces will be encoded to "%20"; if unset, they will be " "
+    \li QUrl::EncodeUnicode: if set, characters above U+0080 will be encoded to their UTF-8
+                             percent-encoded form; if unset, they will be decoded to UTF-16
+    \endlist
+
+    Other flags are ignored (including QUrl::EncodeReserved).
+
+    The \a tableModifications argument can be used to supply extra
+    modifications to the tables, to be applied after the flags above are
+    handled. It consists of a sequence of 16-bit values, where the low 8 bits
+    indicate the character in question and the high 8 bits are either \c
+    EncodeCharacter, \c LeaveCharacter or \c DecodeCharacter.
+ */
+
 Q_AUTOTEST_EXPORT int
 qt_urlRecode(QString &appendTo, const QChar *begin, const QChar *end,
              QUrl::ComponentFormattingOptions encoding, const ushort *tableModifications)
 {
     uchar actionTable[sizeof defaultActionTable];
-    if (encoding & QUrl::DecodeDelimiters && encoding & QUrl::DecodeReserved) {
+    if (!(encoding & QUrl::EncodeDelimiters) && encoding & QUrl::DecodeReserved) {
         // reset the table
         memset(actionTable, DecodeCharacter, sizeof actionTable);
-        if (!(encoding & QUrl::DecodeSpaces))
+        if (encoding & QUrl::EncodeSpaces)
             actionTable[0] = EncodeCharacter;
 
         // these are always encoded
@@ -597,11 +624,11 @@ qt_urlRecode(QString &appendTo, const QChar *begin, const QChar *end,
         actionTable[0x7F - ' '] = EncodeCharacter;
     } else {
         memcpy(actionTable, defaultActionTable, sizeof actionTable);
-        if (encoding & QUrl::DecodeDelimiters)
+        if (!(encoding & QUrl::EncodeDelimiters))
             maskTable(actionTable, delimsMask);
         if (encoding & QUrl::DecodeReserved)
             maskTable(actionTable, reservedMask);
-        if (encoding & QUrl::DecodeSpaces)
+        if (!(encoding & QUrl::EncodeSpaces))
             actionTable[0] = DecodeCharacter; // decode
     }
 
diff --git a/src/testlib/qtest.h b/src/testlib/qtest.h
index d5d30d9003..392e223e39 100644
--- a/src/testlib/qtest.h
+++ b/src/testlib/qtest.h
@@ -142,7 +142,7 @@ template<> inline char *toString(const QRectF &s)
 
 template<> inline char *toString(const QUrl &uri)
 {
-    return qstrdup(uri.toEncoded(QUrl::DecodeDelimiters).constData());
+    return qstrdup(uri.toEncoded().constData());
 }
 
 template<> inline char *toString(const QVariant &v)
diff --git a/tests/auto/corelib/io/qurl/tst_qurl.cpp b/tests/auto/corelib/io/qurl/tst_qurl.cpp
index f8a0edf0dc..5611f5b2f4 100644
--- a/tests/auto/corelib/io/qurl/tst_qurl.cpp
+++ b/tests/auto/corelib/io/qurl/tst_qurl.cpp
@@ -2599,14 +2599,14 @@ void tst_QUrl::componentEncodings_data()
 
     // hostname cannot contain spaces
     QTest::newRow("encoded-space") << QUrl("x://user name:pass word@host/path name?query value#fragment value")
-                                   << int(QUrl::FullyEncoded)
+                                   << int(QUrl::EncodeSpaces)
                                    << "user%20name" << "pass%20word" << "user%20name:pass%20word"
                                    << "host" << "user%20name:pass%20word@host"
                                    << "/path%20name" << "query%20value" << "fragment%20value"
                                    << "x://user%20name:pass%20word@host/path%20name?query%20value#fragment%20value";
 
     QTest::newRow("decoded-space") << QUrl("x://user%20name:pass%20word@host/path%20name?query%20value#fragment%20value")
-                                   << int(QUrl::DecodeSpaces)
+                                   << int(QUrl::MostDecoded)
                                    << "user name" << "pass word" << "user name:pass word"
                                    << "host" << "user name:pass word@host"
                                    << "/path name" << "query value" << "fragment value"
@@ -2624,13 +2624,13 @@ void tst_QUrl::componentEncodings_data()
     // unicode tests
     // hostnames can participate in this test, but we need a top-level domain that accepts Unicode
     QTest::newRow("encoded-unicode") << QUrl(QString::fromUtf8("x://\xc2\x80:\xc3\x90@smørbrød.example.no/\xe0\xa0\x80?\xf0\x90\x80\x80#é"))
-                                     << int(QUrl::FullyEncoded)
+                                     << int(QUrl::EncodeUnicode)
                                      << "%C2%80" << "%C3%90" << "%C2%80:%C3%90"
                                      << "xn--smrbrd-cyad.example.no" << "%C2%80:%C3%90@xn--smrbrd-cyad.example.no"
                                      << "/%E0%A0%80" << "%F0%90%80%80" << "%C3%A9"
                                      << "x://%C2%80:%C3%90@xn--smrbrd-cyad.example.no/%E0%A0%80?%F0%90%80%80#%C3%A9";
     QTest::newRow("decoded-unicode") << QUrl("x://%C2%80:%C3%90@XN--SMRBRD-cyad.example.NO/%E0%A0%80?%F0%90%80%80#%C3%A9")
-                                     << int(QUrl::DecodeUnicode)
+                                     << int(QUrl::MostDecoded)
                                      << QString::fromUtf8("\xc2\x80") << QString::fromUtf8("\xc3\x90")
                                      << QString::fromUtf8("\xc2\x80:\xc3\x90")
                                      << QString::fromUtf8("smørbrød.example.no")
@@ -2661,8 +2661,10 @@ void tst_QUrl::componentEncodings_data()
 
     //    gen-delims    = ":" / "/" / "?" / "#" / "[" / "]" / "@"
     // these are the separators between fields
-    // they must appear encoded in proper URLs everywhere
-    // 1) test the delimiters that, if they were decoded, would change the URL parsing
+    // they must appear encoded in certain positions, no exceptions
+    // in other positions, they can appear decoded, so they always do
+    // 1) test the delimiters that must appear encoded
+    //    (if they were decoded, they'd would change the URL parsing)
     QTest::newRow("encoded-gendelims-changing") << QUrl("x://%5b%3a%2f%3f%23%40%5d:%5b%2f%3f%23%40%5d@host/%2f%3f%23?%23")
                                                 << int(QUrl::MostDecoded)
                                                 << "[:/?#@]" << "[/?#@]" << "[%3A/?#@]:[/?#@]"
@@ -2674,7 +2676,7 @@ void tst_QUrl::componentEncodings_data()
     // and test that %2f is *not* decoded to a slash in the path
     // don't test the query because in this mode it doesn't transform anything
     QTest::newRow("decoded-gendelims-unchanging") << QUrl("x://:%3a@host/%2f%3a%40#%23%3a%2f%3f%40")
-                                                  << int(QUrl::DecodeDelimiters)
+                                                  << int(QUrl::FullyEncoded)
                                                   << "" << ":" << "::"
                                                   << "host" << "::@host"
                                                   << "/%2F:@" << "" << "#:/?@"
@@ -2707,7 +2709,7 @@ void tst_QUrl::componentEncodings_data()
                                             << QString() << "!$()*+,;=:/?[]@" << QString()
                                             << "?!$()*+,;=:/?[]@";
     QTest::newRow("undecoded-delims-query") << QUrl("?%21%24%26%27%28%29%2a%2b%2c%2f%3a%3b%3d%3f%40%5b%5d")
-                                            << int(QUrl::DecodeDelimiters)
+                                            << int(QUrl::MostDecoded)
                                             << QString() << QString() << QString()
                                             << QString() << QString()
                                             << QString() << "%21%24%26%27%28%29%2A%2B%2C%2F%3A%3B%3D%3F%40%5B%5D" << QString()
diff --git a/tests/auto/corelib/io/qurlinternal/tst_qurlinternal.cpp b/tests/auto/corelib/io/qurlinternal/tst_qurlinternal.cpp
index f853bab9e5..3ac2b46964 100644
--- a/tests/auto/corelib/io/qurlinternal/tst_qurlinternal.cpp
+++ b/tests/auto/corelib/io/qurlinternal/tst_qurlinternal.cpp
@@ -812,7 +812,7 @@ void tst_QUrlInternal::correctEncodedMistakes()
     QString output = QTest::currentDataTag();
     expected.prepend(output);
 
-    if (!qt_urlRecode(output, input.constData(), input.constData() + input.length(), QUrl::DecodeUnicode))
+    if (!qt_urlRecode(output, input.constData(), input.constData() + input.length(), 0))
         output += input;
     QCOMPARE(output, expected);
 }
@@ -822,7 +822,7 @@ static void addUtf8Data(const char *name, const char *data)
     QString encoded = QByteArray(data).toPercentEncoding();
     QString decoded = QString::fromUtf8(data);
 
-    QTest::newRow(QByteArray("decode-") + name) << encoded << QUrl::ComponentFormattingOptions(QUrl::DecodeUnicode) << decoded;
+    QTest::newRow(QByteArray("decode-") + name) << encoded << QUrl::ComponentFormattingOptions(QUrl::MostDecoded) << decoded;
     QTest::newRow(QByteArray("encode-") + name) << decoded << QUrl::ComponentFormattingOptions(QUrl::FullyEncoded) << encoded;
 }
 
@@ -877,17 +877,17 @@ void tst_QUrlInternal::encodingRecode_data()
     QTest::newRow("encode-nul") << QString::fromLatin1("abc\0def", 7) << F(QUrl::MostDecoded) << "abc%00def";
 
     // space
-    QTest::newRow("space-leave-decoded") << "Hello World " << F(QUrl::DecodeSpaces) << "Hello World ";
+    QTest::newRow("space-leave-decoded") << "Hello World " << F(QUrl::MostDecoded) << "Hello World ";
     QTest::newRow("space-leave-encoded") << "Hello%20World%20" << F(QUrl::FullyEncoded) << "Hello%20World%20";
     QTest::newRow("space-encode") << "Hello World " << F(QUrl::FullyEncoded) << "Hello%20World%20";
-    QTest::newRow("space-decode") << "Hello%20World%20" << F(QUrl::DecodeSpaces) << "Hello World ";
+    QTest::newRow("space-decode") << "Hello%20World%20" << F(QUrl::MostDecoded) << "Hello World ";
 
     // decode unreserved
     QTest::newRow("unreserved-decode") << "%66%6f%6f%42a%72" << F(QUrl::FullyEncoded) << "fooBar";
 
     // mix encoding with decoding
-    QTest::newRow("encode-control-decode-space") << "\1\2%200" << F(QUrl::DecodeSpaces) << "%01%02 0";
-    QTest::newRow("decode-space-encode-control") << "%20\1\2" << F(QUrl::DecodeSpaces) << " %01%02";
+    QTest::newRow("encode-control-decode-space") << "\1\2%200" << F(QUrl::MostDecoded) << "%01%02 0";
+    QTest::newRow("decode-space-encode-control") << "%20\1\2" << F(QUrl::MostDecoded) << " %01%02";
 
     // decode and encode valid UTF-8 data
     // invalid is tested in encodingRecodeInvalidUtf8
@@ -922,11 +922,11 @@ void tst_QUrlInternal::encodingRecode_data()
     QTest::newRow("ff") << "%ff" << F(QUrl::FullyEncoded) << "%FF";
 
     // decode UTF-8 mixed with non-UTF-8 and unreserved
-    QTest::newRow("utf8-mix-1") << "%80%C2%80" << F(QUrl::DecodeUnicode) << QString::fromUtf8("%80\xC2\x80");
-    QTest::newRow("utf8-mix-2") << "%C2%C2%80" << F(QUrl::DecodeUnicode) << QString::fromUtf8("%C2\xC2\x80");
-    QTest::newRow("utf8-mix-3") << "%E0%C2%80" << F(QUrl::DecodeUnicode) << QString::fromUtf8("%E0\xC2\x80");
-    QTest::newRow("utf8-mix-3") << "A%C2%80" << F(QUrl::DecodeUnicode) << QString::fromUtf8("A\xC2\x80");
-    QTest::newRow("utf8-mix-3") << "%C2%80A" << F(QUrl::DecodeUnicode) << QString::fromUtf8("\xC2\x80""A");
+    QTest::newRow("utf8-mix-1") << "%80%C2%80" << F(QUrl::MostDecoded) << QString::fromUtf8("%80\xC2\x80");
+    QTest::newRow("utf8-mix-2") << "%C2%C2%80" << F(QUrl::MostDecoded) << QString::fromUtf8("%C2\xC2\x80");
+    QTest::newRow("utf8-mix-3") << "%E0%C2%80" << F(QUrl::MostDecoded) << QString::fromUtf8("%E0\xC2\x80");
+    QTest::newRow("utf8-mix-3") << "A%C2%80" << F(QUrl::MostDecoded) << QString::fromUtf8("A\xC2\x80");
+    QTest::newRow("utf8-mix-3") << "%C2%80A" << F(QUrl::MostDecoded) << QString::fromUtf8("\xC2\x80""A");
 }
 
 void tst_QUrlInternal::encodingRecode()
@@ -955,9 +955,9 @@ void tst_QUrlInternal::encodingRecodeInvalidUtf8_data()
     extern void loadNonCharactersRows();
     loadNonCharactersRows();
 
-    QTest::newRow("utf8-mix-4") << QByteArray("\xE0!A2\x80");
-    QTest::newRow("utf8-mix-5") << QByteArray("\xE0\xA2!80");
-    QTest::newRow("utf8-mix-5") << QByteArray("\xE0\xA2\x33");
+    QTest::newRow("utf8-mix-4") << QByteArray("\xE0.A2\x80");
+    QTest::newRow("utf8-mix-5") << QByteArray("\xE0\xA2.80");
+    QTest::newRow("utf8-mix-6") << QByteArray("\xE0\xA2\x33");
 }
 
 void tst_QUrlInternal::encodingRecodeInvalidUtf8()
@@ -968,7 +968,7 @@ void tst_QUrlInternal::encodingRecodeInvalidUtf8()
     // prepend some data to be sure that it remains there
     QString output = QTest::currentDataTag();
 
-    if (!qt_urlRecode(output, input.constData(), input.constData() + input.length(), QUrl::DecodeUnicode))
+    if (!qt_urlRecode(output, input.constData(), input.constData() + input.length(), QUrl::MostDecoded))
         output += input;
     QCOMPARE(output, QTest::currentDataTag() + input);
 
diff --git a/tests/auto/corelib/io/qurlquery/tst_qurlquery.cpp b/tests/auto/corelib/io/qurlquery/tst_qurlquery.cpp
index 24b651a8a3..7148a71153 100644
--- a/tests/auto/corelib/io/qurlquery/tst_qurlquery.cpp
+++ b/tests/auto/corelib/io/qurlquery/tst_qurlquery.cpp
@@ -593,10 +593,13 @@ void tst_QUrlQuery::encodedSetQueryItems_data()
     QTest::newRow("encode-space") << " = " << " " << " " << F(QUrl::FullyEncoded)
                                   << "%20=%20" << "%20" << "%20";
 
-    QTest::newRow("non-delimiters") << "%3C%5C%3E=%7B%7C%7D%5E%60" << "%3C%5C%3E" << "%7B%7C%7D%5E%60" << F(QUrl::PrettyDecoded)
+    // tri-state
+    QTest::newRow("decode-non-delimiters") << "%3C%5C%3E=%7B%7C%7D%5E%60" << "%3C%5C%3E" << "%7B%7C%7D%5E%60" << F(QUrl::DecodeReserved)
                                     << "<\\>={|}^`" << "<\\>" << "{|}^`";
-    QTest::newRow("encode-non-delimiters") << "<\\>={|}^`" << "<\\>" << "{|}^`" << F(QUrl::FullyEncoded)
+    QTest::newRow("encode-non-delimiters") << "<\\>={|}^`" << "<\\>" << "{|}^`" << F(QUrl::EncodeReserved)
                                            << "%3C%5C%3E=%7B%7C%7D%5E%60" << "%3C%5C%3E" << "%7B%7C%7D%5E%60";
+    QTest::newRow("pretty-non-delimiters") << "<\\>={|}^`" << "<\\>" << "{|}^`" << F(QUrl::PrettyDecoded)
+                                           << "%3C%5C%3E=%7B%7C%7D%5E%60" << "<\\>" << "{|}^`";
 
     QTest::newRow("equals") << "%3D=%3D" << "%3D" << "%3D" << F(QUrl::PrettyDecoded)
                             << "%3D=%3D" << "=" << "=";
@@ -606,7 +609,7 @@ void tst_QUrlQuery::encodedSetQueryItems_data()
                                << "%26=%26" << "&" << "&";
     QTest::newRow("hash") << "#=#" << "%23" << "%23" << F(QUrl::PrettyDecoded)
                             << "#=#" << "#" << "#";
-    QTest::newRow("decode-hash") << "%23=%23" << "%23" << "%23" << F(QUrl::DecodeDelimiters)
+    QTest::newRow("decode-hash") << "%23=%23" << "%23" << "%23" << F(QUrl::PrettyDecoded)
                                  << "#=#" << "#" << "#";
 
     QTest::newRow("percent") << "%25=%25" << "%25" << "%25" << F(QUrl::PrettyDecoded)
@@ -623,7 +626,7 @@ void tst_QUrlQuery::encodedSetQueryItems_data()
     // plus signs must not be touched
     QTest::newRow("encode-plus") << "+=+" << "+" << "+" << F(QUrl::FullyEncoded)
                             << "+=+" << "+" << "+";
-    QTest::newRow("decode-2b") << "%2b=%2b" << "%2b" << "%2b" << F(QUrl::DecodeDelimiters)
+    QTest::newRow("decode-2b") << "%2b=%2b" << "%2b" << "%2b" << F(QUrl::MostDecoded)
                             << "%2B=%2B" << "%2B" << "%2B";
 
 
@@ -680,7 +683,7 @@ void tst_QUrlQuery::differentDelimiters()
         expected << qItem("foo", "bar") << qItem("hello", "world");
         COMPARE_ITEMS(query.queryItems(), expected);
         COMPARE_ITEMS(query.queryItems(QUrl::FullyEncoded), expected);
-        COMPARE_ITEMS(query.queryItems(QUrl::DecodeDelimiters), expected);
+        COMPARE_ITEMS(query.queryItems(QUrl::MostDecoded), expected);
     }
 
     {