QString/QByteArray: add lvalue and rvalue overloads of left/mid/right

The first/last/sliced API may be what we suggest users use, but the vast
majority of the installed codebase uses left/mid/right because they've
been available since time immemorial.

An additional benefit of this is to make left() and right() available as
inline methods.

Change-Id: Ifeb6206a9fa04424964bfffd1788383817ed906c
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>

1 files changed, 81 insertions, 0 deletions

diff --git a/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp b/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp
index ec418edcdc..4b3efc8f20 100644
--- a/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp
+++ b/tests/auto/corelib/text/qbytearray/tst_qbytearray.cpp
@@ -145,6 +145,15 @@ static const QByteArray::DataPointer staticNotNullTerminated = {
     4
 };
 
+template <typename String> String detached(String s)
+{
+    if (!s.isNull()) { // detaching loses nullness, but we need to preserve it
+        auto d = s.data();
+        Q_UNUSED(d);
+    }
+    return s;
+}
+
 template <class T> const T &verifyZeroTermination(const T &t) { return t; }
 
 QByteArray verifyZeroTermination(const QByteArray &ba)
@@ -2733,45 +2742,99 @@ void tst_QByteArray::simplified_data()
 void tst_QByteArray::left()
 {
     QByteArray a;
+    QCOMPARE(QByteArray().left(0), QByteArray());
+    QCOMPARE(QByteArray().left(10), QByteArray());
     QCOMPARE(a.left(0), QByteArray());
     QCOMPARE(a.left(10), QByteArray());
     QVERIFY(!a.isDetached());
+    QCOMPARE(QByteArray(a).left(0), QByteArray());
+    QCOMPARE(QByteArray(a).left(10), QByteArray());
+    QCOMPARE(detached(a).left(0), QByteArray());
+    QCOMPARE(detached(a).left(10), QByteArray());
 
     a = QByteArray("abcdefgh");
     const char *ptr = a.constData();
+
+    // lvalue
     QCOMPARE(a.left(5), QByteArray("abcde"));
     QCOMPARE(a.left(20), a);
     QCOMPARE(a.left(-5), QByteArray());
     // calling left() does not modify the source array
     QCOMPARE(a.constData(), ptr);
+
+    // rvalue, not detached
+    QCOMPARE(QByteArray(a).left(5), QByteArray("abcde"));
+    QCOMPARE(QByteArray(a).left(20), a);
+    QCOMPARE(QByteArray(a).left(-5), QByteArray());
+    // calling left() does not modify the source array
+    QCOMPARE(a.constData(), ptr);
+
+    // rvalue, detached
+    QCOMPARE(detached(a).left(5), QByteArray("abcde"));
+    QCOMPARE(detached(a).left(20), a);
+    QCOMPARE(detached(a).left(-5), QByteArray());
+    // calling left() does not modify the source array
+    QCOMPARE(a.constData(), ptr);
 }
 
 void tst_QByteArray::right()
 {
     QByteArray a;
+    QCOMPARE(QByteArray().right(0), QByteArray());
+    QCOMPARE(QByteArray().right(10), QByteArray());
     QCOMPARE(a.right(0), QByteArray());
     QCOMPARE(a.right(10), QByteArray());
     QVERIFY(!a.isDetached());
+    QCOMPARE(QByteArray(a).right(0), QByteArray());
+    QCOMPARE(QByteArray(a).right(10), QByteArray());
+    QCOMPARE(detached(a).right(0), QByteArray());
+    QCOMPARE(detached(a).right(10), QByteArray());
 
     a = QByteArray("abcdefgh");
     const char *ptr = a.constData();
+
+    // lvalue
     QCOMPARE(a.right(5), QByteArray("defgh"));
     QCOMPARE(a.right(20), a);
     QCOMPARE(a.right(-5), QByteArray());
     // calling right() does not modify the source array
     QCOMPARE(a.constData(), ptr);
+
+    // rvalue, not detached
+    QCOMPARE(QByteArray(a).right(5), QByteArray("defgh"));
+    QCOMPARE(QByteArray(a).right(20), a);
+    QCOMPARE(QByteArray(a).right(-5), QByteArray());
+    // calling right() does not modify the source array
+    QCOMPARE(a.constData(), ptr);
+
+    // rvalue, detached
+    QCOMPARE(detached(a).right(5), QByteArray("defgh"));
+    QCOMPARE(detached(a).right(20), a);
+    QCOMPARE(detached(a).right(-5), QByteArray());
+    // calling right() does not modify the source array
+    QCOMPARE(a.constData(), ptr);
 }
 
 void tst_QByteArray::mid()
 {
     QByteArray a;
+    QCOMPARE(QByteArray().mid(0), QByteArray());
+    QCOMPARE(a.mid(0, 10), QByteArray());
     QCOMPARE(a.mid(0), QByteArray());
     QCOMPARE(a.mid(0, 10), QByteArray());
     QCOMPARE(a.mid(10), QByteArray());
     QVERIFY(!a.isDetached());
+    QCOMPARE(QByteArray(a).mid(0), QByteArray());
+    QCOMPARE(QByteArray(a).mid(0, 10), QByteArray());
+    QCOMPARE(QByteArray(a).mid(10), QByteArray());
+    QCOMPARE(detached(a).mid(0), QByteArray());
+    QCOMPARE(detached(a).mid(0, 10), QByteArray());
+    QCOMPARE(detached(a).mid(10), QByteArray());
 
     a = QByteArray("abcdefgh");
     const char *ptr = a.constData();
+
+    // lvalue
     QCOMPARE(a.mid(2), QByteArray("cdefgh"));
     QCOMPARE(a.mid(2, 3), QByteArray("cde"));
     QCOMPARE(a.mid(20), QByteArray());
@@ -2779,6 +2842,24 @@ void tst_QByteArray::mid()
     QCOMPARE(a.mid(-5, 8), QByteArray("abc"));
     // calling mid() does not modify the source array
     QCOMPARE(a.constData(), ptr);
+
+    // rvalue, not detached
+    QCOMPARE(QByteArray(a).mid(2), QByteArray("cdefgh"));
+    QCOMPARE(QByteArray(a).mid(2, 3), QByteArray("cde"));
+    QCOMPARE(QByteArray(a).mid(20), QByteArray());
+    QCOMPARE(QByteArray(a).mid(-5), QByteArray("abcdefgh"));
+    QCOMPARE(QByteArray(a).mid(-5, 8), QByteArray("abc"));
+    // calling mid() does not modify the source array
+    QCOMPARE(a.constData(), ptr);
+
+    // rvalue, detached
+    QCOMPARE(detached(a).mid(2), QByteArray("cdefgh"));
+    QCOMPARE(detached(a).mid(2, 3), QByteArray("cde"));
+    QCOMPARE(detached(a).mid(20), QByteArray());
+    QCOMPARE(detached(a).mid(-5), QByteArray("abcdefgh"));
+    QCOMPARE(detached(a).mid(-5, 8), QByteArray("abc"));
+    // calling mid() does not modify the source array
+    QCOMPARE(a.constData(), ptr);
 }
 
 void tst_QByteArray::length()