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

**

** 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$

**

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

#include <QtTest/QtTest>

#include "q3valuelist.h"

#include <q3valuelist.h>

//TESTED_CLASS=

//TESTED_FILES=

class tst_Q3ValueList : public QObject

{

Q_OBJECT

public:

    tst_Q3ValueList();

    virtual ~tst_Q3ValueList();

public slots:

    void init();

    void cleanup();

private slots:

    void isEmpty();

    void clear();

    void count();

    void size();

    void contains();

    void findIndex();

    void indexing();

    void firstLast();

    void frontBack();

    void beginEnd();

    void pushing();

    void popping();

    void remove();

    void erase();

    void fromLast();

    void append();

    // Doesn't have own test function since all

    // other functions are heavy users of it,

    // thus it must work correctly

    void prepend();

    void insert();

    void find();

    void opEqualNotEqual();

    void opPlus();

    void opPlusEqual();

    void opStreamOut();

    void shared();

    void detach_on_append();

    void detach_on_prepend();

    void detach_on_insert1();

    void detach_on_insert2();

    void detach_on_it_assign();

    void detach_on_ref_assign();

    void detach_on_clear();

    void detach_on_erase1();

    void detach_on_erase2();

    void detach_on_opPE1();

    void detach_on_opPE2();

    void detach_on_opStream();

    void detach_on_pop_front();

    void detach_on_pop_back();

    void detach_on_push_front();

    void detach_on_push_back();

    void detach_on_remove1();

    void detach_on_remove2();

};

tst_Q3ValueList::tst_Q3ValueList()

{

}

tst_Q3ValueList::~tst_Q3ValueList()

{

}

void tst_Q3ValueList::init()

{

}

void tst_Q3ValueList::cleanup()

{

}

void tst_Q3ValueList::isEmpty()

{

    Q3ValueList<int> a;

    QVERIFY( a.isEmpty() );

    QVERIFY( a.empty() );

    a.append( 1 );

    QVERIFY( !a.isEmpty() );

    QVERIFY( !a.empty() );

}

void tst_Q3ValueList::clear()

{

    Q3ValueList<int> a;

    a.append( 1 );

    a.append( 2 );

    a.append( 3 );

    a.clear();

    QVERIFY( a.isEmpty() );

}

void tst_Q3ValueList::count()

{

    Q3ValueList<int> a;

    QCOMPARE( (int)a.count(), 0 );

    a.append( 1 );

    QCOMPARE( (int)a.count(), 1 );

    a.append( 2 );

    QCOMPARE( (int)a.count(), 2 );

    a.append( 3 );

    QCOMPARE( (int)a.count(), 3 );

    a.clear();

    QCOMPARE( (int)a.count(), 0 );

}

void tst_Q3ValueList::size()

{

    Q3ValueList<int> a;

    QCOMPARE( (int)a.size(), 0 );

    a.append( 1 );

    QCOMPARE( (int)a.size(), 1 );

    a.append( 2 );

    QCOMPARE( (int)a.size(), 2 );

    a.append( 3 );

    QCOMPARE( (int)a.size(), 3 );

    a.clear();

    QCOMPARE( (int)a.size(), 0 );

}

void tst_Q3ValueList::contains()

{

    Q3ValueList<int> a;

    a.append( 1 );

    a.append( 10 );

    a.append( 100 );

    a.append( 1000 );

    a.append( 1000 );

    QCOMPARE( (int)a.contains(1), 1 );

    QCOMPARE( (int)a.contains(10), 1 );

    QCOMPARE( (int)a.contains(99), 0 );

    QCOMPARE( (int)a.contains(1000), 2 );

}

void tst_Q3ValueList::findIndex()

{

    Q3ValueList<int> a;

    a.append( 1 );

    a.append( 10 );

    a.append( 100 );

    a.append( 1000 );

    a.append( 1000 );

    QCOMPARE( a.findIndex( 0 ), -1 );

    QCOMPARE( a.findIndex( 1 ), 0 );

    QCOMPARE( a.findIndex( 1000 ), 3 );

}

void tst_Q3ValueList::indexing()

{

    Q3ValueList<int> a;

    a.append( 1 );

    a.append( 10 );

    a.append( 99 );

    QCOMPARE( a[0], 1 );

    QCOMPARE( a[1], 10 );

    QCOMPARE( a[2], 99 );

    QCOMPARE( *(a.at(0)), 1 );

    QCOMPARE( *(a.at(1)), 10 );

    QCOMPARE( *(a.at(2)), 99 );

    a[1] = 11;

    QCOMPARE( a[1], 11 );

    *(a.at(0)) = 2;

    QCOMPARE( a[0], 2 );

}

void tst_Q3ValueList::firstLast()

{

    Q3ValueList<int> a;

    a.append( 1 );

    a.append( 10 );

    a.append( 100 );

    a.append( 1000 );

    a.append( 10000 );

    QCOMPARE( a.first(), 1 );

    QCOMPARE( a.last(), 10000 );

    a.first() = 2;

    a.last() = 20000;

    QCOMPARE( a.first(), 2 );

    QCOMPARE( a.last(), 20000 );

}

void tst_Q3ValueList::frontBack()

{

    Q3ValueList<int> a;

    a.append( 1 );

    a.append( 10 );

    a.append( 100 );

    a.append( 1000 );

    a.append( 10000 );

    QCOMPARE( a.front(), 1 );

    QCOMPARE( a.back(), 10000 );

    a.first() = 2;

    a.last() = 20000;

    QCOMPARE( a.front(), 2 );

    QCOMPARE( a.back(), 20000 );

}

void tst_Q3ValueList::beginEnd()

{

    Q3ValueList<int> a;

    a.append( 1 );

    a.append( 10 );

    a.append( 100 );

    Q3ValueListConstIterator<int> cit1 = a.begin();

    Q3ValueListConstIterator<int> cit2 = a.end();

    QCOMPARE( *(cit1), 1 );

    QCOMPARE( *(--cit2), 100 );

    Q3ValueListIterator<int> it1 = a.begin();

    Q3ValueListIterator<int> it2 = a.end();

    *(it1) = 2;

    *(--it2) = 200;

    // Using const iterators to verify

    QCOMPARE( *(cit1), 2 );

    QCOMPARE( *(cit2), 200 );

    Q3ValueList<int> b;

    b.append( 1 );

    Q3ValueList<int> b2 = b;

    QVERIFY( b.constBegin() == b2.constBegin() );

    QVERIFY( b.constEnd() == b2.constEnd() );

    b2.append( 2 );

    QVERIFY( b.constBegin() != b2.constBegin() );

    QVERIFY( b2.constBegin() == b2.constBegin() );

}

void tst_Q3ValueList::pushing()

{

    Q3ValueList<int> a;

    a.append( 100 );

    a.push_front( 10 );

    QCOMPARE( a.first(), 10 );

    QCOMPARE( a.last(), 100 );

    a.push_back( 1000 );

    QCOMPARE( a.first(), 10 );

    QCOMPARE( a.last(), 1000 );

}

void tst_Q3ValueList::popping()

{

    Q3ValueList<int> a;

    a.append( 1 );

    a.append( 10 );

    a.append( 100 );

    a.append( 1000 );

    a.append( 10000 );

    a.pop_front();

    QCOMPARE( a.first(), 10 );

    QCOMPARE( a.last(), 10000 );

    a.pop_back();

    QCOMPARE( a.first(), 10 );

    QCOMPARE( a.last(), 1000 );

    QCOMPARE( (int)a.count(), 3 );

    a.pop_back();

    a.pop_back();

    a.pop_back();

    QVERIFY( a.isEmpty() );

}

void tst_Q3ValueList::remove()

{

    {

        Q3ValueList<int> a;

        a.append( 1 );

        a.append( 10 );

        a.append( 100 );

        a.append( 1000 );

        a.append( 1000 );

        a.append( 10000 );

        QCOMPARE( (uint)a.remove(100), (uint)1 );

        QCOMPARE( (uint)a.remove(1000), (uint)2 );

        QCOMPARE( (int)a.first(), 1 );

        QCOMPARE( (int)a.last(), 10000 );

        a.remove( a.at(0) );

        QCOMPARE( (int)a.first(), 10 );

        QCOMPARE( (int)a.last(), 10000 );

        a.remove( a.at(1) );

        QCOMPARE( (int)a.first(), 10 );

        QCOMPARE( (int)a.last(), 10 );

    }

    {

        Q3ValueList<int> a;

        a.append( 1 );

        a.append( 10 );

        a.append( 100 );

        a.append( 1000 );

        a.append( 10000 );

        Q3ValueList<int>::Iterator it = a.begin();

        ++it;

        QVERIFY(*it == 10);

        it = a.remove(it);

        QVERIFY(*it == 100);

        it = a.remove(it);

        QVERIFY(*it == 1000);

        it = a.remove(it);

        QVERIFY(*it == 10000);

        it = a.remove(it);

        QVERIFY(it == a.end());

    }

}

void tst_Q3ValueList::erase()

{

    Q3ValueList<int> a;

    a.append( 1 );

    a.append( 5 );

    a.append( 10 );

    a.append( 50 );

    a.append( 100 );

    a.append( 500 );

    a.append( 1000 );

    a.append( 5000 );

    a.append( 10000 );

    a.append( 50000 );

    a.erase( a.at(0), a.at(5) ); // Remove 1 to 100 (inclusive)

    QCOMPARE( (int)a.first(), 500 );

    QCOMPARE( (int)a.last(), 50000 );

    Q3ValueListIterator<int> it = a.erase( a.at(2) ); // remove 5000

    QCOMPARE( *(it), 10000 );

    it = a.erase( a.at(3) ); // remove 50000

    QVERIFY( (it == a.end()) );

}

void tst_Q3ValueList::fromLast()

{

    Q3ValueList<int> a;

    Q3ValueListIterator<int> it = a.fromLast();

    QVERIFY( (it == a.end()) );

    a.append( 1 );

    a.append( 10 );

    a.append( 100 );

    it = a.fromLast();

    QVERIFY( (it != a.end()) );

    QCOMPARE( a.last(), 100 );

    *(a.fromLast()) = 200;

    QCOMPARE( a.last(), 200 );

}

void tst_Q3ValueList::prepend()

{

    Q3ValueList<int> a;

    a.append( 1 );

    a.append( 10 );

    a.append( 100 );

    QCOMPARE( (int)a[0], 1 );

    Q3ValueList<int>::Iterator it = a.prepend( 1000 );

    QCOMPARE( (int)a[0], 1000 );

    QVERIFY( *it == 1000 );

}

void tst_Q3ValueList::insert()

{

    Q3ValueList<int> a;

    a.append( 1 );

    a.append( 10 );

    a.append( 100 );

    Q3ValueListIterator<int> it = a.fromLast();

    it = a.insert( it, 1000 );

    QCOMPARE( *(it), 1000 );

    QCOMPARE( *(++it), 100 );

    QCOMPARE( (int)a.count(), 4 );

    it = a.fromLast();

    a.insert( it, 10, 1234 );

    QCOMPARE( (int)a.count(), 14 );

}

void tst_Q3ValueList::find()

{

    Q3ValueList<int> a;

    a.append( 1 );

    a.append( 10 );

    a.append( 100 );

    a.append( 1000 );

    a.append( 10000 );

    a.append( 10000 );

    a.append( 20000 );

    a.append( 30000 );

    // Constant iterators

    Q3ValueListConstIterator<int> cit1 = a.find( 200 );

    QVERIFY( (cit1 == a.end()) );

    cit1 = a.find( 1000 );

    QCOMPARE( *(cit1), 1000 );

    QCOMPARE( *(++cit1), 10000 );

    QCOMPARE( *(++cit1), 10000 );

    QCOMPARE( *(++cit1), 20000 );

    cit1 = a.at( 3 );

    Q3ValueListConstIterator<int> cit2 = a.find( cit1, 20000 );

    QCOMPARE( *(cit2), 20000 );

    QCOMPARE( *(++cit2), 30000 );

    // Non constant iterators

    Q3ValueListIterator<int> it1 = a.find( 200 );

    QVERIFY( (it1 == a.end()) );

    it1 = a.find( 1000 );

    QCOMPARE( *(it1), 1000 );

    QCOMPARE( *(++it1), 10000 );

    QCOMPARE( *(++it1), 10000 );

    QCOMPARE( *(++it1), 20000 );

    *(it1) = 25000;

    it1--;

    it1++;

    QCOMPARE( *(it1), 25000 );

    Q3ValueListIterator<int> it2 = a.find( it1, 30000 );

    *(it2) = 35000;

    QCOMPARE( *(it2), 35000 );

}

void tst_Q3ValueList::opEqualNotEqual()

{

    Q3ValueList<int> a;

    a.append( 1 );

    a.append( 10 );

    a.append( 100 );

    Q3ValueList<int> b;

    b.append( 1 );

    b.append( 10 );

    b.append( 100 );

    QVERIFY( a == b );

    QVERIFY( !(a != b) );