/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the test suite of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** 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, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

// test the container forwards

#include <QtContainerFwd>

static QCache<int, int> *cacheX;

static QHash<int, int> *hashX;

static QLinkedList<int> *linkedListX;

static QList<int> *listX;

static QMap<int, int> *mapX;

static QMultiHash<int, int> *multiHashX;

static QMultiMap<int, int> *multiMapX;

static QPair<int, int> *pairX;

static QQueue<int> *queueX;

static QSet<int> *setX;

static QStack<int> *stackX;

static QVarLengthArray<int> *varLengthArrayX;

static QVarLengthArray<int, 512> *varLengthArrayY;

static QVector<int> *vectorX;

void foo()

{

    cacheX = 0;

    hashX = 0;

    linkedListX = 0;

    listX = 0;

    mapX = 0;

    multiHashX = 0;

    multiMapX = 0;

    pairX = 0;

    queueX = 0;

    setX = 0;

    stackX = 0;

    varLengthArrayX = 0;

    varLengthArrayY = 0;

    vectorX = 0;

}

#include <QtTest/QtTest>

#ifndef QT_NO_STL

#  include <algorithm>

#endif

#include "qalgorithms.h"

#include "qbitarray.h"

#include "qbytearray.h"

#include "qcache.h"

#include "qhash.h"

#include "qlinkedlist.h"

#include "qlist.h"

#include "qmap.h"

#include "qpair.h"

#include "qregexp.h"

#include "qset.h"

#include "qstack.h"

#include "qstring.h"

#include "qstringlist.h"

#include "qvarlengtharray.h"

#include "qvector.h"

#include "qqueue.h"

#ifdef QT3_SUPPORT

#include "q3cleanuphandler.h"

#endif

// Do not test initialization of pods on msvc6 and msvc 2002

// This is a known issue

#if defined Q_CC_MSVC && _MSC_VER < 1310

#   define NOPODINITIALIZATION

#endif

template class QList<int>;

//TESTED_FILES=

class tst_Collections : public QObject

{

    Q_OBJECT

public:

    tst_Collections();

    ~tst_Collections();

public slots:

    void init();

    void cleanup();

private slots:

    void typeinfo();

    void qstring();

    void list();

    void linkedList();

    void vector();

    void byteArray();

    void stack();

    void hash();

    void map();

    void bitArray();

    void cache();

    void regexp();

    void pair();

    void cleanupHandler();

    void sharableQList();

    void sharableQLinkedList();

    void sharableQVector();

    void sharableQMap();

    void sharableQHash();

    void q_foreach();

    void conversions();

    void javaStyleIterators();

    void constAndNonConstStlIterators();

#ifndef QT_NO_STL

    void vector_stl_data();

    void vector_stl();

    void list_stl_data();

    void list_stl();

    void linkedlist_stl_data();

    void linkedlist_stl();

#endif

    void q_init();

    void pointersize();

    void containerInstantiation();

    void qtimerList();

    void containerTypedefs();

    void forwardDeclared();

};

struct LargeStatic {

    static int count;

    LargeStatic():c(count) { ++count; }

    LargeStatic(const LargeStatic& o):c(o.c) { ++count; }

    ~LargeStatic() { --count; }

    int c;

    int data[8];

};

int LargeStatic::count = 0;

struct Movable {

    static int count;

    Movable():c(count) { ++count; }

    Movable(const Movable& o):c(o.c) { ++count; }

    ~Movable() { --count; }

    int c;

};

int Movable::count = 0;

QT_BEGIN_NAMESPACE

Q_DECLARE_TYPEINFO(Movable, Q_MOVABLE_TYPE);

QT_END_NAMESPACE

struct Pod {

    int i1, i2;

#if defined NOPODINITIALIZATION

    Pod() : i1(0), i2(0) { }

#endif

};

tst_Collections::tst_Collections()

{

}

tst_Collections::~tst_Collections()

{

}

void tst_Collections::init()

{

}

void tst_Collections::cleanup()

{

}

void tst_Collections::typeinfo()

{

    QVERIFY(QTypeInfo<int*>::isPointer);

    QVERIFY(!QTypeInfo<int>::isPointer);

    QVERIFY(QTypeInfo<QString>::isComplex);

    QVERIFY(!QTypeInfo<int>::isComplex);

}

void tst_Collections::list()

{

    {

	QList<int> list;

	QVERIFY(list.isEmpty());

	list.append(1);

	QVERIFY(list.size() == 1);

	QVERIFY(*list.begin() == 1);

	list.push_back(2);

	list += (3);

	list << 4 << 5 << 6;

	QVERIFY(!list.isEmpty());

	QVERIFY(list.size() == 6);

	QVERIFY(list.end() - list.begin() == list.size());

#if !defined(QT_NO_STL) && !defined(Q_CC_MSVC) && !defined(Q_CC_SUN)

	QVERIFY(std::binary_search(list.begin(), list.end(), 2) == true);

	QVERIFY(std::binary_search(list.begin(), list.end(), 9) == false);

#endif

	QVERIFY(qBinaryFind(list.begin(), list.end(), 2) == list.begin() + 1);

	QVERIFY(qLowerBound(list.begin(), list.end(), 2) == list.begin() + 1);

        QVERIFY(qUpperBound(list.begin(), list.end(), 2) == list.begin() + 2);

	QVERIFY(qBinaryFind(list.begin(), list.end(), 9) == list.end());

	QVERIFY(qLowerBound(list.begin(), list.end(), 9) == list.end());

        QVERIFY(qUpperBound(list.begin(), list.end(), 9) == list.end());

	{

	    int sum = 0;

	    QListIterator<int> i(list);

	    while (i.hasNext())

		sum += i.next();

	    QVERIFY(sum == 21);

	}

	{

	    QList<int> list1;

            list1 << 1 << 2 << 3 << 5 << 7 << 8 << 9;

	    QList<int> list2 = list1;

	    QMutableListIterator<int> i1(list1);

            while (i1.hasNext()) {

		if (i1.next() % 2 != 0)

		    i1.remove();

	    }

	    QMutableListIterator<int> i2(list2);

            i2.toBack();

            while (i2.hasPrevious()) {

		if (i2.previous() % 2 != 0)

		    i2.remove();

            }

            QVERIFY(list1.size() == 2);

            QVERIFY(list2.size() == 2);

            QVERIFY(list1 == list2);

        }

	{

	    int sum = 0;

	    for (int i = 0; i < list.size(); ++i)

		sum += list[i];

	    QVERIFY(sum == 21);

	}

	{

	    int sum = 0;

	    QList<int>::const_iterator i = list.begin();

	    while (i != list.end())

		sum += *i++;

	    QVERIFY(sum == 21);

	}

	{

	    int sum = 0;

	    QList<int>::ConstIterator i = list.begin();

	    while (i != list.end())

		sum += *i++;

	    QVERIFY(sum == 21);

	}

	{

	    QList<int>::Iterator i = list.begin();

            i += 2;

            QCOMPARE(*i, 3);

            i -= 1;

            QCOMPARE(*i, 2);

	}

	{

	    QList<int>::ConstIterator i = list.begin();

            i += 2;

            QCOMPARE(*i, 3);

            i -= 1;

            QCOMPARE(*i, 2);

	}

	{

	    int sum = 0;

	    int i;

	    for (i = 0; i < list.size(); ++i)

		list[i] = list[i] +1;

	    for (i = 0; i < list.size(); ++i)

		sum += list[i];

	    QVERIFY(sum == 21 + list.size());

	}

	{

	    int sum = 0;

	    int i;

	    for (i = 0; i < list.size(); ++i)

		--list[i];

	    for (i = 0; i < list.size(); ++i)

		sum += list[i];

	    QVERIFY(sum == 21);

	}

	{

	    QMutableListIterator<int> i(list);

	    while (i.hasNext())

		i.setValue(2*i.next());

	}

	{

	    int sum = 0;

	    QListIterator<int> i(list);

	    i.toBack();

	    while (i.hasPrevious())

		sum += i.previous();

	    QVERIFY(sum == 2*21);

	}

	{

	    QMutableListIterator<int> i(list);

	    i.toBack();

	    while (i.hasPrevious())

		i.setValue(2*i.previous());

	}

	{

	    int sum = 0;

	    QListIterator<int> i(list);

	    i.toBack();

	    while (i.hasPrevious())

		sum += i.previous();

	    QVERIFY(sum == 2*2*21);

	}

	{

	    QMutableListIterator<int> i(list);

	    while (i.hasNext()) {

		int a = i.next();

		i.insert(a);

	    }

	}

	{

	    int sum = 0;

	    QList<int>::iterator i = list.begin();

	    while (i != list.end())

		sum += *i++;

	    QVERIFY(sum == 2*2*2*21);

	}

	{

	    int duplicates = 0;

	    QListIterator<int> i(list);

	    while (i.hasNext()) {

		int a = i.next();

		if (i.hasNext() && a == i.peekNext())

		    duplicates++;

	    }

	    QVERIFY(duplicates == 6);

	}

	{

	    int duplicates = 0;

	    QListIterator<int> i(list);

	    i.toBack();

	    while (i.hasPrevious()) {

		int a = i.previous();

		if (i.hasPrevious() && a == i.peekPrevious())

		    duplicates++;

	    }

	    QVERIFY(duplicates == 6);

	}

	{

	    QMutableListIterator<int> i(list);

	    while (i.hasNext()) {

		int a = i.next();

		if (i.hasNext() &&

		     i.peekNext() == a)

		    i.remove();

	    }

	}

	{

	    int duplicates = 0;

	    QMutableListIterator<int> i = list;

	    i.toBack();

	    while (i.hasPrevious()) {

		int a = i.previous();

		if (i.hasPrevious() && a == i.peekPrevious())

		    duplicates++;

	    }

	    QVERIFY(duplicates == 0);

	}

	{

	    QVERIFY(list.size() == 6);

	    QMutableListIterator<int> i = list;

	    while (i.hasNext()) {

		int a = i.peekNext();

		i.insert(42);

		QVERIFY(i.peekPrevious() == 42 && i.peekNext() == a);

		i.next();

	    }

	    QVERIFY(list.size() == 12);

	    i.toFront();

	    while (i.findNext(42))

		i.remove();

	}

	{

	    QList<int> l;

	    l << 4 << 8 << 12 << 16 << 20 << 24;

	    QVERIFY(l == list);

	    QList<int> copy = list;

	    list += list;

	    QVERIFY(l != list && l.size() == list.size()/2 && l == copy);

	    l += copy;

	    QVERIFY(l == list);

	    list = copy;

	}

	{

	    QList<int> copy = list;

	    list << 8;

	    QVERIFY(list.indexOf(8) == 1);

	    QVERIFY(list.indexOf(8, list.indexOf(8)+1) == 6);

	    int a = list.indexOf(8);

	    QVERIFY(list.count(8) == 2);

	    int r = list.removeAll(8);

	    QVERIFY(r == 2);

	    list.insert(a, 8);

	    QVERIFY(list == copy);

	}

        {

            QList<QString> list;

            list << "one" << "two" << "three" << "four" << "five" << "six";

            while (!list.isEmpty())

                list.removeAll(list.first());

        }

        {

            QList<QString> list;

            list << "one" << "two" << "one" << "two";

            QVERIFY(!list.removeOne("three"));

            QVERIFY(list.removeOne("two"));

            QCOMPARE(list, QList<QString>() << "one" << "one" << "two");;

            QVERIFY(list.removeOne("two"));

            QCOMPARE(list, QList<QString>() << "one" << "one");

            QVERIFY(!list.removeOne("two"));

            QCOMPARE(list, QList<QString>() << "one" << "one");

            QVERIFY(list.removeOne("one"));

            QCOMPARE(list, QList<QString>() << "one");

            QVERIFY(list.removeOne("one"));

            QVERIFY(list.isEmpty());

            QVERIFY(!list.removeOne("one"));

            QVERIFY(list.isEmpty());

        }

	{

	    QList<int> copy = list;

	    list << 8;

	    QVERIFY(list.lastIndexOf(8) == 6);

	    QVERIFY(list.lastIndexOf(8, list.lastIndexOf(8)-1) == 1);

	    list = copy;

	}

	{

	    QList<int> copy = list;

	    list.insert(3, 999);

	    QVERIFY(list[3] == 999);

	    list.replace(3, 222);

	    QVERIFY(list[3] == 222);

	    QVERIFY(list.contains(222) && ! list.contains(999));

	    list.removeAt(3);

	    list = copy;

	    QVERIFY(list == copy);

	}

	{

	    list.clear();

	    QVERIFY(list.isEmpty());

	    QVERIFY(list.begin() == list.end());

	    QListIterator<int> i(list);

	    QVERIFY(!i.hasNext() && !i.hasPrevious());

	}

	{

	    QList<int> l1;

	    QList<int> l2;

	    l1 << 1 << 2 << 3;

	    l2 << 4 << 5 << 6;

	    QList<int> l3 = l1 + l2;

	    l1 += l2;

	    QVERIFY(l3 == l1);

	}

	{

	    QList<int> list;

	    QVERIFY(list.isEmpty());

	    list.append(1);

	    QList<int> list2;

	    list2 = list;

	    list2.clear();

	    QVERIFY(list2.size() == 0);

	    QVERIFY(list.size() == 1);

	}

	{

	    QList<int> list;

	    list.append(1);

	    list = list;

	    QVERIFY(list.size() == 1);

	}

    }