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

**

** Copyright (C) 2010 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$

**

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

#include <QtTest/QtTest>

#include <qset.h>

#include <qdebug.h>

//TESTED_CLASS=

//TESTED_FILES=

int toNumber(const QString &str)

{

    int res = 0;

    for (int i = 0; i < str.length(); ++i)

        res = (res * 10) + str[i].digitValue();

    return res;

}

class tst_QSet : public QObject

{

    Q_OBJECT

public:

    tst_QSet() {}

    virtual ~tst_QSet() {}

private slots:

    void operator_eq();

    void size();

    void capacity();

    void reserve();

    void squeeze();

    void detach();

    void isDetached();

    void clear();

    void remove();

    void contains();

    void containsSet();

    void begin();

    void end();

    void insert();

    void setOperations();

    void stlIterator();

    void stlMutableIterator();

    void javaIterator();

    void javaMutableIterator();

    void makeSureTheComfortFunctionsCompile();

};

void tst_QSet::operator_eq()

{

    {

        QSet<int> set1, set2;

        QVERIFY(set1 == set2);

        QVERIFY(!(set1 != set2));

        set1.insert(1);

        QVERIFY(set1 != set2);

        QVERIFY(!(set1 == set2));

        set2.insert(1);

        QVERIFY(set1 == set2);

        QVERIFY(!(set1 != set2));

        set2.insert(1);

        QVERIFY(set1 == set2);

        QVERIFY(!(set1 != set2));

        set1.insert(2);

        QVERIFY(set1 != set2);

        QVERIFY(!(set1 == set2));

    }

    {

        QSet<QString> set1, set2;

        QVERIFY(set1 == set2);

        QVERIFY(!(set1 != set2));

        set1.insert("one");

        QVERIFY(set1 != set2);

        QVERIFY(!(set1 == set2));

        set2.insert("one");

        QVERIFY(set1 == set2);

        QVERIFY(!(set1 != set2));

        set2.insert("one");

        QVERIFY(set1 == set2);

        QVERIFY(!(set1 != set2));

        set1.insert("two");

        QVERIFY(set1 != set2);

        QVERIFY(!(set1 == set2));

    }

    {

        // Task 102658

        QSet<QString> a;

        QSet<QString> b;

        a += "otto";

        b += "willy";

        QVERIFY(a != b);

        QVERIFY(!(a == b));

    }

}

void tst_QSet::size()

{

    QSet<int> set;

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

    QVERIFY(set.isEmpty());

    QVERIFY(set.count() == set.size());

    QVERIFY(set.isEmpty() == set.empty());

    set.insert(1);

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

    QVERIFY(!set.isEmpty());

    QVERIFY(set.count() == set.size());

    QVERIFY(set.isEmpty() == set.empty());

    set.insert(1);

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

    QVERIFY(!set.isEmpty());

    QVERIFY(set.count() == set.size());

    QVERIFY(set.isEmpty() == set.empty());

    set.insert(2);

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

    QVERIFY(!set.isEmpty());

    QVERIFY(set.count() == set.size());

    QVERIFY(set.isEmpty() == set.empty());

    set.remove(1);

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

    QVERIFY(!set.isEmpty());

    QVERIFY(set.count() == set.size());

    QVERIFY(set.isEmpty() == set.empty());

    set.remove(1);

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

    QVERIFY(!set.isEmpty());

    QVERIFY(set.count() == set.size());

    QVERIFY(set.isEmpty() == set.empty());

    set.remove(2);

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

    QVERIFY(set.isEmpty());

    QVERIFY(set.count() == set.size());

    QVERIFY(set.isEmpty() == set.empty());

}

void tst_QSet::capacity()

{

    QSet<int> set;

    int n = set.capacity();

    QVERIFY(n == 0);

    for (int i = 0; i < 1000; ++i) {

        set.insert(i);

        QVERIFY(set.capacity() >= set.size());

    }

}

void tst_QSet::reserve()

{

    QSet<int> set;

    int n = set.capacity();

    QVERIFY(n == 0);

    set.reserve(1000);

    QVERIFY(set.capacity() >= 1000);

    for (int i = 0; i < 500; ++i)

        set.insert(i);

    QVERIFY(set.capacity() >= 1000);

    for (int j = 0; j < 500; ++j)

        set.remove(j);

    QVERIFY(set.capacity() >= 1000);

    set.clear();

    QVERIFY(set.capacity() == 0);

}

void tst_QSet::squeeze()

{

    QSet<int> set;

    int n = set.capacity();

    QVERIFY(n == 0);

    set.reserve(1000);

    QVERIFY(set.capacity() >= 1000);

    set.squeeze();

    QVERIFY(set.capacity() < 100);

    for (int i = 0; i < 500; ++i)

        set.insert(i);

    QVERIFY(set.capacity() >= 500 && set.capacity() < 10000);

    set.reserve(50000);

    QVERIFY(set.capacity() >= 50000);

    set.squeeze();

    QVERIFY(set.capacity() < 500);

    set.remove(499);

    QVERIFY(set.capacity() < 500);

    set.insert(499);

    QVERIFY(set.capacity() >= 500);

    for (int i = 0; i < 500; ++i)

        set.remove(i);

    set.squeeze();

    QVERIFY(set.capacity() < 100);

}

void tst_QSet::detach()

{

    QSet<int> set;

    set.detach();

    set.insert(1);

    set.insert(2);

    set.detach();

    QSet<int> copy = set;

    set.detach();

}

void tst_QSet::isDetached()

{

    QSet<int> set1, set2;

    QVERIFY(!set1.isDetached()); // shared_null

    QVERIFY(!set2.isDetached()); // shared_null

    set1.insert(1);

    QVERIFY(set1.isDetached());

    QVERIFY(!set2.isDetached()); // shared_null

    set2 = set1;

    QVERIFY(!set1.isDetached());

    QVERIFY(!set2.isDetached());

    set1.detach();

    QVERIFY(set1.isDetached());

    QVERIFY(set2.isDetached());

}

void tst_QSet::clear()

{

    QSet<QString> set1, set2;

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

    set1.clear();

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

    set1.insert("foo");

    QVERIFY(set1.size() != 0);

    set2 = set1;

    set1.clear();

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

    QVERIFY(set2.size() != 0);

    set2.clear();

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

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

}

void tst_QSet::remove()

{

    QSet<QString> set1;

    for (int i = 0; i < 500; ++i)

        set1.insert(QString::number(i));

    QCOMPARE(set1.size(), 500);

    for (int j = 0; j < 500; ++j) {

        set1.remove(QString::number((j * 17) % 500));

        QCOMPARE(set1.size(), 500 - j - 1);

    }

}

void tst_QSet::contains()

{

    QSet<QString> set1;

    for (int i = 0; i < 500; ++i) {

        QVERIFY(!set1.contains(QString::number(i)));

        set1.insert(QString::number(i));

        QVERIFY(set1.contains(QString::number(i)));

    }

    QCOMPARE(set1.size(), 500);

    for (int j = 0; j < 500; ++j) {

        int i = (j * 17) % 500;

        QVERIFY(set1.contains(QString::number(i)));

        set1.remove(QString::number(i));

        QVERIFY(!set1.contains(QString::number(i)));

    }

}

void tst_QSet::containsSet()

{

    QSet<QString> set1;

    QSet<QString> set2;

    // empty set contains the empty set

    QVERIFY(set1.contains(set2));

    for (int i = 0; i < 500; ++i) {

        set1.insert(QString::number(i));

        set2.insert(QString::number(i));

    }

    QVERIFY(set1.contains(set2));

    set2.remove(QString::number(19));

    set2.remove(QString::number(82));

    set2.remove(QString::number(7));

    QVERIFY(set1.contains(set2));

    set1.remove(QString::number(23));

    QVERIFY(!set1.contains(set2));

    // filled set contains the empty set as well

    QSet<QString> set3;

    QVERIFY(set1.contains(set3));

    // the empty set doesn't contain a filled set

    QVERIFY(!set3.contains(set1));

    // verify const signature

    const QSet<QString> set4;

    QVERIFY(set3.contains(set4));

}

void tst_QSet::begin()

{

    QSet<int> set1;

    QSet<int> set2 = set1;

    {

        QSet<int>::const_iterator i = set1.constBegin();

        QSet<int>::const_iterator j = set1.constBegin();

        QSet<int>::const_iterator k = set2.constBegin();

        QSet<int>::const_iterator ell = set2.constBegin();

        QVERIFY(i == j);

        QVERIFY(k == ell);

        QVERIFY(i == k);

        QVERIFY(j == ell);

    }

    set1.insert(44);

    {

        QSet<int>::const_iterator i = set1.constBegin();

        QSet<int>::const_iterator j = set1.constBegin();

        QSet<int>::const_iterator k = set2.constBegin();

        QSet<int>::const_iterator ell = set2.constBegin();

        QVERIFY(i == j);

        QVERIFY(k == ell);

        QVERIFY(i != k);

        QVERIFY(j != ell);

    }

    set2 = set1;

    {

        QSet<int>::const_iterator i = set1.constBegin();

        QSet<int>::const_iterator j = set1.constBegin();

        QSet<int>::const_iterator k = set2.constBegin();

        QSet<int>::const_iterator ell = set2.constBegin();

        QVERIFY(i == j);

        QVERIFY(k == ell);

        QVERIFY(i == k);

        QVERIFY(j == ell);

    }

}

void tst_QSet::end()

{

    QSet<int> set1;

    QSet<int> set2 = set1;

    {

        QSet<int>::const_iterator i = set1.constEnd();

        QSet<int>::const_iterator j = set1.constEnd();

        QSet<int>::const_iterator k = set2.constEnd();

        QSet<int>::const_iterator ell = set2.constEnd();

        QVERIFY(i == j);

        QVERIFY(k == ell);

        QVERIFY(i == k);

        QVERIFY(j == ell);

        QVERIFY(set1.constBegin() == set1.constEnd());

        QVERIFY(set2.constBegin() == set2.constEnd());

    }

    set1.insert(44);

    {

        QSet<int>::const_iterator i = set1.constEnd();

        QSet<int>::const_iterator j = set1.constEnd();

        QSet<int>::const_iterator k = set2.constEnd();

        QSet<int>::const_iterator ell = set2.constEnd();

        QVERIFY(i == j);

        QVERIFY(k == ell);

        QVERIFY(i != k);

        QVERIFY(j != ell);

        QVERIFY(set1.constBegin() != set1.constEnd());

        QVERIFY(set2.constBegin() == set2.constEnd());

    }

    set2 = set1;

    {

        QSet<int>::const_iterator i = set1.constEnd();

        QSet<int>::const_iterator j = set1.constEnd();

        QSet<int>::const_iterator k = set2.constEnd();

        QSet<int>::const_iterator ell = set2.constEnd();

        QVERIFY(i == j);

        QVERIFY(k == ell);

        QVERIFY(i == k);

        QVERIFY(j == ell);

        QVERIFY(set1.constBegin() != set1.constEnd());

        QVERIFY(set2.constBegin() != set2.constEnd());

    }

    set1.clear();

    set2.clear();

    QVERIFY(set1.constBegin() == set1.constEnd());

    QVERIFY(set2.constBegin() == set2.constEnd());

}

void tst_QSet::insert()

{

    {

        QSet<int> set1;

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

        set1.insert(1);

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

        set1.insert(2);

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

        set1.insert(2);

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

        QVERIFY(set1.contains(2));

        set1.remove(2);

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

        QVERIFY(!set1.contains(2));

        set1.insert(2);

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

        QVERIFY(set1.contains(2));

    }

    {

        QSet<int> set1;

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

        set1 << 1;

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

        set1 << 2;

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

        set1 << 2;

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

        QVERIFY(set1.contains(2));

        set1.remove(2);

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

        QVERIFY(!set1.contains(2));

        set1 << 2;

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

        QVERIFY(set1.contains(2));

    }

}