Long live QByteArrayList!

Initial submission of a new class QByteArrayList with the
purpose of aggregating and then joining QByteArray instances.

[ChangeLog][QtCore] Added new QByteArrayList class.

Done-with: Marc Mutz <marc.mutz@kdab.com>
Change-Id: I503af58f125d7f44fef10360177490c933e5840f
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>

8 files changed, 832 insertions, 0 deletions

diff --git a/src/corelib/doc/snippets/qbytearraylist/main.cpp b/src/corelib/doc/snippets/qbytearraylist/main.cpp
new file mode 100644
index 0000000000..be462dea60
--- /dev/null
+++ b/src/corelib/doc/snippets/qbytearraylist/main.cpp
@@ -0,0 +1,51 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 by Southwest Research Institute (R)
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** 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, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#include <QByteArrayList>
+
+int main(int, char **)
+{
+    QByteArray ba1, ba2, ba3;
+//! [0]
+    QByteArrayList longerList = (QByteArrayList() << ba1 << ba2 << ba3);
+//! [0]
+}
diff --git a/src/corelib/doc/snippets/qbytearraylist/qbytearraylist.pro b/src/corelib/doc/snippets/qbytearraylist/qbytearraylist.pro
new file mode 100644
index 0000000000..87397b491d
--- /dev/null
+++ b/src/corelib/doc/snippets/qbytearraylist/qbytearraylist.pro
@@ -0,0 +1,2 @@
+QT = core
+SOURCES = main.cpp
diff --git a/src/corelib/tools/qbytearraylist.cpp b/src/corelib/tools/qbytearraylist.cpp
new file mode 100644
index 0000000000..beb6a32df7
--- /dev/null
+++ b/src/corelib/tools/qbytearraylist.cpp
@@ -0,0 +1,294 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Copyright (C) 2014 by Southwest Research Institute (R)
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** 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, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qbytearraylist.h>
+
+QT_BEGIN_NAMESPACE
+
+/*! \typedef QByteArrayListIterator
+    \relates QByteArrayList
+
+    The QByteArrayListIterator type definition provides a Java-style const
+    iterator for QByteArrayList.
+
+    QByteArrayList provides both \l{Java-style iterators} and
+    \l{STL-style iterators}. The Java-style const iterator is simply
+    a type definition for QListIterator<QByteArray>.
+
+    \sa QMutableByteArrayListIterator, QByteArrayList::const_iterator
+*/
+
+/*! \typedef QMutableByteArrayListIterator
+    \relates QByteArrayList
+
+    The QByteArrayListIterator type definition provides a Java-style
+    non-const iterator for QByteArrayList.
+
+    QByteArrayList provides both \l{Java-style iterators} and
+    \l{STL-style iterators}. The Java-style non-const iterator is
+    simply a type definition for QMutableListIterator<QByteArray>.
+
+    \sa QByteArrayListIterator, QByteArrayList::iterator
+*/
+
+/*!
+    \class QByteArrayList
+    \inmodule QtCore
+    \since 5.4
+    \brief The QByteArrayList class provides a list of byte arrays.
+
+    \ingroup tools
+    \ingroup shared
+    \ingroup string-processing
+
+    \reentrant
+
+    QByteArrayList inherits from QList<QByteArray>. Like QList, QByteArrayList is
+    \l{implicitly shared}. It provides fast index-based access as well as fast
+    insertions and removals. Passing string lists as value parameters is both
+    fast and safe.
+
+    All of QList's functionality also applies to QByteArrayList. For example, you
+    can use isEmpty() to test whether the list is empty, and you can call
+    functions like append(), prepend(), insert(), replace(), removeAll(),
+    removeAt(), removeFirst(), removeLast(), and removeOne() to modify a
+    QByteArrayList. In addition, QByteArrayList provides several join()
+    methods for concatenating the list into a single QByteArray.
+
+    The purpose of QByteArrayList is quite different from that of QStringList.
+    Whereas QStringList has many methods for manipulation of elements within
+    the list, QByteArrayList does not.
+    Normally, QStringList should be used whenever working with a list of printable
+    strings. QByteArrayList should be used to handle and efficiently join large blobs
+    of binary data, as when sequentially receiving serialized data through a
+    QIODevice.
+
+    \sa QByteArray, QStringList
+*/
+
+/*!
+    \fn QByteArrayList::QByteArrayList()
+
+    Constructs an empty byte array list.
+*/
+
+/*!
+    \fn QByteArrayList::QByteArrayList(const QByteArray &ba)
+
+    Constructs a byte array list that contains the given byte array,
+    \a ba. Longer lists are easily created like this:
+
+    \snippet qbytearraylist/main.cpp 0
+
+    \sa append()
+*/
+
+/*!
+    \fn QByteArrayList::QByteArrayList(const QList<QByteArray> &other)
+
+    Constructs a copy of \a other.
+
+    This operation takes \l{constant time}, because QByteArrayList is
+    \l{implicitly shared}. This makes returning a QByteArrayList from a
+    function very fast. If a shared instance is modified, it will be
+    copied (copy-on-write), and that takes \l{linear time}.
+
+    \sa operator=()
+*/
+
+/*!
+    \fn QByteArrayList::QByteArrayList(QList<QByteArray> &&other)
+
+    \overload
+
+    Move-constructs from \a other.
+
+    This constructor is only enabled if the compiler supports C++11
+    move semantics.
+
+    \sa operator=()
+*/
+
+/*! \fn QByteArrayList::QByteArrayList(std::initializer_list<QByteArray> args)
+
+    Constructs a list from a std::initializer_list given by \a args.
+
+    This constructor is only enabled if the compiler supports C++11 initializer
+    lists.
+*/
+
+/*!
+    \fn QByteArrayList &QByteArrayList::operator=(const QList<QByteArray> &other)
+
+    Assigns the contents of \a other to this byte array list and returns
+    a reference to \c *this.
+*/
+
+/*!
+    \fn QByteArrayList &QByteArrayList::operator=(QList<QByteArray> &&other)
+
+    \overload
+
+    Move-assigns the contents of \a other to this byte array list and returns
+    a reference to \c *this.
+
+    This operator is only enabled if the compiler supports C++11 move
+    semantics.
+*/
+
+/*!
+    \fn QByteArrayList &QByteArrayList::operator=(std::initializer_list<QByteArray> args)
+
+    \overload
+
+    Assigns the byte arrays from the initializer_list \a args to this byte array
+    list and returns a reference to \c *this.
+
+    This operator is only enabled if the compiler supports C++11 initializer
+    lists.
+*/
+
+/*!
+    \fn QByteArray QByteArrayList::join() const
+
+    Joins all the byte arrays into a single byte array.
+*/
+
+/*!
+    \fn QByteArray QByteArrayList::join(const QByteArray &separator) const
+
+    Joins all the byte arrays into a single byte array with each
+    element separated by the given \a separator.
+*/
+
+/*!
+    \fn QByteArray QByteArrayList::join(char separator) const
+
+    Joins all the byte arrays into a single byte array with each
+    element separated by the given \a separator.
+*/
+
+static int QByteArrayList_joinedSize(const QByteArrayList *that, int seplen)
+{
+    int totalLength = 0;
+    const int size = that->size();
+
+    for (int i = 0; i < size; ++i)
+        totalLength += that->at(i).size();
+
+    if (size > 0)
+        totalLength += seplen * (size - 1);
+
+    return totalLength;
+}
+
+QByteArray QtPrivate::QByteArrayList_join(const QByteArrayList *that, const char *sep, int seplen)
+{
+    QByteArray res;
+    if (const int joinedSize = QByteArrayList_joinedSize(that, seplen))
+        res.reserve(joinedSize); // don't call reserve(0) - it allocates one byte for the NUL
+    const int size = that->size();
+    for (int i = 0; i < size; ++i) {
+        if (i)
+            res.append(sep, seplen);
+        res += that->at(i);
+    }
+    return res;
+}
+
+/*!
+    \fn QByteArrayList operator+(const QByteArrayList &list1, const QByteArrayList &list2)
+    \fn QByteArrayList operator+(const QByteArrayList &list1, const QList<QByteArray> &list2)
+    \fn QByteArrayList operator+(const QList<QByteArray> &list1, const QByteArrayList &list2)
+    \fn QByteArrayList operator+(QByteArrayList &&list1, const QByteArrayList &list2)
+    \fn QByteArrayList operator+(QByteArrayList &&list1, const QList<QByteArray> &list2)
+    \relates QByteArrayList
+
+    Returns a byte array list that is the concatenation of \a list1 and \a list2.
+*/
+
+/*!
+    \fn QByteArrayList& operator+=(QByteArrayList &list1, const QList<QByteArray> &list2)
+    \relates QByteArrayList
+
+    Appends \a list2 (which may be a QByteArrayList itself) to \a
+    list1 and returns a reference to \a list1.
+*/
+
+/*!
+    \fn QByteArrayList &QByteArrayList::operator<<(const QByteArray &ba)
+
+    Appends the given byte array, \a ba, to this byte array list and returns
+    a reference to the byte array list.
+
+    \sa append()
+*/
+
+/*!
+    \fn QByteArrayList &QByteArrayList::operator<<(const QList<QByteArray> &other)
+
+    \overload
+
+    Appends the list of byte arrays \a other (which may be a
+    QByteArrayList itself) to this byte array list and returns a
+    reference to \c *this.  */
+
+/*!
+    \fn QDataStream &operator>>(QDataStream &in, QByteArrayList &list)
+    \relates QByteArrayList
+
+    Reads a byte array list from the given \a in stream into the specified
+    \a list.
+
+    \sa {Serializing Qt Data Types}
+*/
+
+/*!
+    \fn QDataStream &operator<<(QDataStream &out, const QByteArrayList &list)
+    \relates QByteArrayList
+
+    Writes the given byte array \a list to the specified \a out stream.
+
+    \sa {Serializing Qt Data Types}
+*/
+
+QT_END_NAMESPACE
diff --git a/src/corelib/tools/qbytearraylist.h b/src/corelib/tools/qbytearraylist.h
new file mode 100644
index 0000000000..efcba8e7ea
--- /dev/null
+++ b/src/corelib/tools/qbytearraylist.h
@@ -0,0 +1,186 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Copyright (C) 2014 by Southwest Research Institute (R)
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** 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, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+
+#ifndef QBYTEARRAYLIST_H
+#define QBYTEARRAYLIST_H
+
+#include <QtCore/qdatastream.h>
+#include <QtCore/qlist.h>
+#include <QtCore/qbytearray.h>
+
+QT_BEGIN_NAMESPACE
+
+
+typedef QListIterator<QByteArray> QByteArrayListIterator;
+typedef QMutableListIterator<QByteArray> QMutableByteArrayListIterator;
+
+class QByteArrayList : public QList<QByteArray>
+{
+public:
+    QByteArrayList() { }
+    explicit QByteArrayList(const QByteArray &i) { append(i); }
+    QByteArrayList(const QList<QByteArray> &l) : QList<QByteArray>(l) { }
+#ifdef Q_COMPILER_RVALUE_REFS
+    QByteArrayList(QList<QByteArray> &&l) : QList<QByteArray>(qMove(l)) { }
+#endif
+#ifdef Q_COMPILER_INITIALIZER_LISTS
+    QByteArrayList(std::initializer_list<QByteArray> args) : QList<QByteArray>(args) { }
+#endif
+    // compiler-generated copy/move ctor/assignment operators are ok
+    // compiler-generated dtor is ok
+    // inherited swap() is ok (sic!)
+
+    // For the operators, we could just say using QList<QByteArray>::operator{=,<<},
+    // but they would not return QByteArrayList&, so we need to write inline forwarders:
+    QByteArrayList &operator=(const QList<QByteArray> &other)
+    { QList<QByteArray>::operator=(other); return *this; }
+#ifdef Q_COMPILER_RVALUE_REFS
+    QByteArrayList &operator=(QList<QByteArray> &&other)
+    { QList<QByteArray>::operator=(qMove(other)); return *this; }
+#endif
+    // if this is missing, assignment from an initializer_list is ambiguous:
+#ifdef Q_COMPILER_INITIALIZER_LISTS
+    QByteArrayList &operator=(std::initializer_list<QByteArray> args)
+    { QByteArrayList copy(args); swap(copy); return *this; }
+#endif
+    QByteArrayList &operator<<(const QByteArray &str)
+    { QList<QByteArray>::operator<<(str); return *this; }
+    QByteArrayList &operator<<(const QList<QByteArray> &l)
+    { QList<QByteArray>::operator<<(l); return *this; }
+
+    //
+    // actual functionality provided on top of what QList<QByteArray> provides starts here:
+    //
+    inline QByteArray join() const;
+    inline QByteArray join(const QByteArray &sep) const;
+    inline QByteArray join(char sep) const;
+};
+
+Q_DECLARE_TYPEINFO(QByteArrayList, Q_MOVABLE_TYPE);
+
+namespace QtPrivate {
+    QByteArray Q_CORE_EXPORT QByteArrayList_join(const QByteArrayList *that, const char *separator, int separatorLength);
+}
+
+inline QByteArray QByteArrayList::join() const
+{
+    return QtPrivate::QByteArrayList_join(this, 0, 0);
+}
+
+inline QByteArray QByteArrayList::join(const QByteArray &sep) const
+{
+    return QtPrivate::QByteArrayList_join(this, sep.constData(), sep.size());
+}
+
+inline QByteArray QByteArrayList::join(char sep) const
+{
+    return QtPrivate::QByteArrayList_join(this, &sep, 1);
+}
+
+inline QByteArrayList operator+(const QByteArrayList &lhs, const QByteArrayList &rhs)
+{
+    QByteArrayList res = lhs;
+    res += rhs;
+    return res;
+}
+
+#ifdef Q_COMPILER_RVALUE_REFS
+inline QByteArrayList operator+(QByteArrayList &&lhs, const QByteArrayList &rhs)
+{
+    lhs += rhs;
+    return qMove(lhs);
+}
+#endif
+
+inline QByteArrayList operator+(const QByteArrayList &lhs, const QList<QByteArray> &rhs)
+{
+    QByteArrayList res = lhs;
+    res += rhs;
+    return res;
+}
+
+#ifdef Q_COMPILER_RVALUE_REFS
+inline QByteArrayList operator+(QByteArrayList &&lhs, const QList<QByteArray> &rhs)
+{
+    lhs += rhs;
+    return qMove(lhs);
+}
+#endif
+
+inline QByteArrayList operator+(const QList<QByteArray> &lhs, const QByteArrayList &rhs)
+{
+    QByteArrayList res = lhs;
+    res += rhs;
+    return res;
+}
+
+#if 0 // ambiguous with QList<QByteArray>::operator+(const QList<QByteArray> &) const
+#ifdef Q_COMPILER_RVALUE_REFS
+inline QByteArrayList operator+(QList<QByteArray> &&lhs, const QByteArrayList &rhs)
+{
+    lhs += rhs;
+    return qMove(lhs);
+}
+#endif
+#endif
+
+inline QByteArrayList& operator+=(QByteArrayList &lhs, const QList<QByteArray> &rhs)
+{
+    lhs.append(rhs);
+    return lhs;
+}
+
+#ifndef QT_NO_DATASTREAM
+inline QDataStream &operator>>(QDataStream &in, QByteArrayList &list)
+{
+    return operator>>(in, static_cast<QList<QByteArray> &>(list));
+}
+inline QDataStream &operator<<(QDataStream &out, const QByteArrayList &list)
+{
+    return operator<<(out, static_cast<const QList<QByteArray> &>(list));
+}
+#endif // QT_NO_DATASTREAM
+
+QT_END_NAMESPACE
+
+#endif // QBYTEARRAYLIST_H
diff --git a/src/corelib/tools/tools.pri b/src/corelib/tools/tools.pri
index 467f870249..af0ed228bd 100644
--- a/src/corelib/tools/tools.pri
+++ b/src/corelib/tools/tools.pri
@@ -9,6 +9,7 @@ HEADERS +=  \
         tools/qarraydatapointer.h \
         tools/qbitarray.h \
         tools/qbytearray.h \
+        tools/qbytearraylist.h \
         tools/qbytearraymatcher.h \
         tools/qbytedata_p.h \
         tools/qcache.h \
@@ -77,6 +78,7 @@ SOURCES += \
         tools/qarraydata.cpp \
         tools/qbitarray.cpp \
         tools/qbytearray.cpp \
+        tools/qbytearraylist.cpp \
         tools/qbytearraymatcher.cpp \
         tools/qcollator.cpp \
         tools/qcommandlineoption.cpp \
diff --git a/tests/auto/corelib/tools/qbytearraylist/qbytearraylist.pro b/tests/auto/corelib/tools/qbytearraylist/qbytearraylist.pro
new file mode 100644
index 0000000000..2cd4522f67
--- /dev/null
+++ b/tests/auto/corelib/tools/qbytearraylist/qbytearraylist.pro
@@ -0,0 +1,4 @@
+CONFIG += testcase parallel_test
+TARGET = tst_qbytearraylist
+QT = core testlib
+SOURCES = tst_qbytearraylist.cpp
diff --git a/tests/auto/corelib/tools/qbytearraylist/tst_qbytearraylist.cpp b/tests/auto/corelib/tools/qbytearraylist/tst_qbytearraylist.cpp
new file mode 100644
index 0000000000..7d409ca1b8
--- /dev/null
+++ b/tests/auto/corelib/tools/qbytearraylist/tst_qbytearraylist.cpp
@@ -0,0 +1,292 @@
+/****************************************************************************
+**
+** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
+** Copyright (C) 2014 by Southwest Research Institute (R)
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** 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, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtTest/QtTest>
+#include <qbytearraylist.h>
+
+#include <qmetatype.h>
+
+Q_DECLARE_METATYPE(QByteArrayList)
+
+class tst_QByteArrayList : public QObject
+{
+    Q_OBJECT
+private slots:
+    void join() const;
+    void join_data() const;
+    void joinByteArray() const;
+    void joinByteArray_data() const;
+    void joinChar() const;
+    void joinChar_data() const;
+    void joinEmptiness() const;
+
+    void operator_plus() const;
+    void operator_plus_data() const;
+
+    void initializerList() const;
+};
+
+void tst_QByteArrayList::join() const
+{
+    QFETCH(QByteArrayList, input);
+    QFETCH(QByteArray, expectedResult);
+
+    QCOMPARE(input.join(), expectedResult);
+}
+
+void tst_QByteArrayList::join_data() const
+{
+    QTest::addColumn<QByteArrayList>("input");
+    QTest::addColumn<QByteArray>("expectedResult");
+
+    QTest::newRow("data1") << QByteArrayList()
+                           << QByteArray();
+
+    QTest::newRow("data2") << QByteArrayList("one")
+                           << QByteArray("one");
+
+    QTest::newRow("data3") << (QByteArrayList() << "a" << "b")
+                           << QByteArray("ab");
+
+    QTest::newRow("data4") << (QByteArrayList() << "a" << "b" << "c")
+                           << QByteArray("abc");
+}
+
+void tst_QByteArrayList::joinByteArray() const
+{
+    QFETCH(QByteArrayList, input);
+    QFETCH(QByteArray, separator);
+    QFETCH(QByteArray, expectedResult);
+
+    QCOMPARE(input.join(separator), expectedResult);
+}
+
+void tst_QByteArrayList::joinByteArray_data() const
+{
+    QTest::addColumn<QByteArrayList>("input");
+    QTest::addColumn<QByteArray>("separator");
+    QTest::addColumn<QByteArray>("expectedResult");
+
+    QTest::newRow("data1") << QByteArrayList()
+                           << QByteArray()
+                           << QByteArray();
+
+    QTest::newRow("data2") << QByteArrayList()
+                           << QByteArray("separator")
+                           << QByteArray();
+
+    QTest::newRow("data3") << QByteArrayList("one")
+                           << QByteArray("separator")
+                           << QByteArray("one");
+
+    QTest::newRow("data4") << (QByteArrayList() << "a" << "b")
+                           << QByteArray(" ")
+                           << QByteArray("a b");
+
+    QTest::newRow("data5") << (QByteArrayList() << "a" << "b" << "c")
+                           << QByteArray(" ")
+                           << QByteArray("a b c");
+
+    QTest::newRow("data6") << (QByteArrayList()  << "a" << "b" << "c")
+                           << QByteArray()
+                           << QByteArray("abc");
+
+    QTest::newRow("data7") << (QByteArrayList()  << "a" << "b" << "c")
+                           << QByteArray("") //empty
+                           << QByteArray("abc");
+}
+
+void tst_QByteArrayList::joinChar() const
+{
+    QFETCH(QByteArrayList, input);
+    QFETCH(char, separator);
+    QFETCH(QByteArray, expectedResult);
+
+    QCOMPARE(input.join(separator), expectedResult);
+}
+
+void tst_QByteArrayList::joinChar_data() const
+{
+    QTest::addColumn<QByteArrayList>("input");
+    QTest::addColumn<char>("separator");
+    QTest::addColumn<QByteArray>("expectedResult");
+
+    QTest::newRow("data1") << QByteArrayList()
+                           << ' '
+                           << QByteArray();
+
+    QTest::newRow("data2") << (QByteArrayList() << "a a" << "b")
+                           << ' '
+                           << QByteArray("a a b");
+
+    QTest::newRow("data3") << (QByteArrayList() << "a" << "b" << "c c")
+                           << ' '
+                           << QByteArray("a b c c");
+}
+
+void tst_QByteArrayList::joinEmptiness() const
+{
+    QByteArrayList list;
+    QByteArray string = list.join(QByteArray());
+
+    QVERIFY(string.isEmpty());
+    QVERIFY(string.isNull());
+}
+
+void tst_QByteArrayList::operator_plus() const
+{
+    QFETCH(QByteArrayList, lhs);
+    QFETCH(QByteArrayList, rhs);
+    QFETCH(QByteArrayList, expectedResult);
+
+    // operator+ for const lvalues
+    {
+        const QByteArrayList bal1 = lhs;
+        const QByteArrayList bal2 = rhs;
+        QCOMPARE(bal1 + bal2, expectedResult);
+    }
+    {
+        const QList<QByteArray> lba1 = lhs;
+        const QByteArrayList bal2 = rhs;
+        QCOMPARE(lba1 + bal2, expectedResult);
+    }
+    {
+        const QByteArrayList bal1 = lhs;
+        const QList<QByteArray> lba2 = rhs;
+        QCOMPARE(bal1 + lba2, expectedResult);
+    }
+    {
+        const QList<QByteArray> lba1 = lhs;
+        const QList<QByteArray> lba2 = rhs;
+        QCOMPARE(lba1 + lba2, QList<QByteArray>(expectedResult)); // check we don't mess with old code
+    }
+
+    // operator+ for rvalues (only lhs)
+    {
+        QByteArrayList bal1 = lhs;
+        const QByteArrayList bal2 = rhs;
+        QCOMPARE(qMove(bal1) + bal2, expectedResult);
+    }
+    {
+        QList<QByteArray> lba1 = lhs;
+        const QByteArrayList bal2 = rhs;
+        QCOMPARE(qMove(lba1) + bal2, expectedResult);
+    }
+    {
+        QByteArrayList bal1 = lhs;
+        const QList<QByteArray> lba2 = rhs;
+        QCOMPARE(qMove(bal1) + lba2, expectedResult);
+    }
+    {
+        QList<QByteArray> lba1 = lhs;
+        const QList<QByteArray> lba2 = rhs;
+        QCOMPARE(qMove(lba1) + lba2, QList<QByteArray>(expectedResult)); // check we don't mess with old code
+    }
+
+    // operator += for const lvalues
+    {
+        QByteArrayList bal1 = lhs;
+        const QByteArrayList bal2 = rhs;
+        QCOMPARE(bal1 += bal2, expectedResult);
+    }
+    {
+        QByteArrayList bal1 = lhs;
+        const QList<QByteArray> lba2 = rhs;
+        QCOMPARE(bal1 += lba2, expectedResult);
+    }
+    {
+        QList<QByteArray> lba1 = lhs;
+        const QByteArrayList bal2 = rhs;
+        QCOMPARE(lba1 += bal2, QList<QByteArray>(expectedResult));
+    }
+
+    QByteArrayList t1 = lhs;
+    QByteArrayList t2 = rhs;
+
+    QCOMPARE(qMove(t1) + t2, expectedResult);
+}
+
+void tst_QByteArrayList::operator_plus_data() const
+{
+    QTest::addColumn<QByteArrayList>("lhs");
+    QTest::addColumn<QByteArrayList>("rhs");
+    QTest::addColumn<QByteArrayList>("expectedResult");
+
+    QTest::newRow("simpl") << ( QByteArrayList() << "a" )
+                           << ( QByteArrayList() << "b" << "c" )
+                           << ( QByteArrayList() << "a" << "b" << "c" );
+
+    QTest::newRow("blank1") << QByteArrayList()
+                            << QByteArrayList()
+                            << QByteArrayList();
+
+    QTest::newRow("blank2") << ( QByteArrayList() )
+                            << ( QByteArrayList() << "b" << "c" )
+                            << ( QByteArrayList() << "b" << "c" );
+
+    QTest::newRow("empty1") << ( QByteArrayList() << "" )
+                            << ( QByteArrayList() << "b" << "c" )
+                            << ( QByteArrayList() << "" << "b" << "c" );
+
+    QTest::newRow("empty2") << ( QByteArrayList() << "a" )
+                            << ( QByteArrayList() << "" << "c" )
+                            << ( QByteArrayList() << "a" << "" << "c" );
+}
+
+void tst_QByteArrayList::initializerList() const
+{
+#ifdef Q_COMPILER_INITIALIZER_LISTS
+    // constructor
+    QByteArrayList v1 = {QByteArray("hello"),"world",QByteArray("plop")};
+    QCOMPARE(v1, (QByteArrayList() << "hello" << "world" << "plop"));
+    QCOMPARE(v1, (QByteArrayList{"hello","world","plop"}));
+    // assignment operator (through implicit temporary)
+    QByteArrayList v2;
+    v2 = {QByteArray("hello"),"world",QByteArray("plop")};
+    QCOMPARE(v2, v1);
+#else
+    QSKIP("This test requires C++11 initializer_list support in the compiler.");
+#endif
+}
+
+QTEST_APPLESS_MAIN(tst_QByteArrayList)
+#include "tst_qbytearraylist.moc"
diff --git a/tests/auto/corelib/tools/tools.pro b/tests/auto/corelib/tools/tools.pro
index 19cb060960..ce37ccb18b 100644
--- a/tests/auto/corelib/tools/tools.pro
+++ b/tests/auto/corelib/tools/tools.pro
@@ -6,6 +6,7 @@ SUBDIRS=\
     qarraydata_strictiterators \
     qbitarray \
     qbytearray \
+    qbytearraylist \
     qbytearraymatcher \
     qbytedatabuffer \
     qcache \