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>

3 files changed, 297 insertions, 0 deletions

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 \