/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Copyright (C) 2014 by Southwest Research Institute (R)
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** 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 The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.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 indexOf_data() const;
    void indexOf() 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(std::move(bal1) + bal2, expectedResult);
    }
    {
        QList<QByteArray> lba1 = lhs;
        const QByteArrayList bal2 = rhs;
        QCOMPARE(std::move(lba1) + bal2, expectedResult);
    }
    {
        QByteArrayList bal1 = lhs;
        const QList<QByteArray> lba2 = rhs;
        QCOMPARE(std::move(bal1) + lba2, expectedResult);
    }
    {
        QList<QByteArray> lba1 = lhs;
        const QList<QByteArray> lba2 = rhs;
        QCOMPARE(std::move(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(std::move(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::indexOf_data() const
{
    QTest::addColumn<QByteArrayList>("list");
    QTest::addColumn<QByteArray>("item");
    QTest::addColumn<int>("expectedResult");

    QTest::newRow("empty") << QByteArrayList() << QByteArray("a") << -1;
    QTest::newRow("found_1") << ( QByteArrayList() << "a" ) << QByteArray("a") << 0;
    QTest::newRow("not_found_1") << ( QByteArrayList() << "a" ) << QByteArray("b") << -1;
    QTest::newRow("found_2") << ( QByteArrayList() << "hello" << "world" ) << QByteArray("world") << 1;
    QTest::newRow("returns_first") << ( QByteArrayList() << "hello" << "world" << "hello" << "again" ) << QByteArray("hello") << 0;
}

void tst_QByteArrayList::indexOf() const
{
    QFETCH(QByteArrayList, list);
    QFETCH(QByteArray, item);
    QFETCH(int, expectedResult);

    QCOMPARE(list.indexOf(item), expectedResult);
    QCOMPARE(list.indexOf(item.constData()), expectedResult);
}

void tst_QByteArrayList::initializerList() const
{
    // 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);
}

QTEST_APPLESS_MAIN(tst_QByteArrayList)
#include "tst_qbytearraylist.moc"