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

**

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

**

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

#define QT_STRICT_ITERATORS

#include <QtTest/QtTest>

#include <QDebug>

#include <qmap.h>

//TESTED_CLASS=

//TESTED_FILES=

class tst_QMap : public QObject

{

    Q_OBJECT

public:

    tst_QMap();

public slots:

    void init();

private slots:

    void count();

    void clear();

    void beginEnd();

    void key();

    void operator_eq();

    void empty();

    void contains();

    void find();

    void constFind();

    void lowerUpperBound();

    void mergeCompare();

    void take();

    void iterators();

    void keys_values_uniqueKeys();

    void qmultimap_specific();

};

tst_QMap::tst_QMap()

{

}

typedef QMap<QString, QString> StringMap;

class MyClass

{

public:

    MyClass() {

       ++count;

//     qDebug("creating MyClass count=%d", count);

    }

    MyClass( const QString& c) {

	count++; str = c;

// 	qDebug("creating MyClass '%s' count = %d", str.latin1(), count);

    }

    ~MyClass() {

	count--;

// 	qDebug("deleting MyClass '%s' count = %d", str.latin1(), count);

    }

    MyClass( const MyClass& c ) {

	count++; str = c.str;

// 	qDebug("creating MyClass '%s' count = %d", str.latin1(), count);

    }

    MyClass &operator =(const MyClass &o) {

// 	qDebug("copying MyClass '%s'", o.str.latin1());

	str = o.str; return *this;

    }

    QString str;

    static int count;

};

int MyClass::count = 0;

typedef QMap<QString, MyClass> MyMap;

void tst_QMap::init()

{

    MyClass::count = 0;

}

void tst_QMap::count()

{

    {

	MyMap map;

	MyMap map2( map );

	QCOMPARE( map.count(), 0 );

	QCOMPARE( map2.count(), 0 );

	QCOMPARE( MyClass::count, int(0) );

	// detach

	map2["Hallo"] = MyClass( "Fritz" );

	QCOMPARE( map.count(), 0 );

        QCOMPARE( map2.count(), 1 );

#ifndef Q_CC_SUN

	QCOMPARE( MyClass::count, 1 );

#endif

    }

    QCOMPARE( MyClass::count, int(0) );

    {

	typedef QMap<QString, MyClass> Map;

	Map map;

	QCOMPARE( map.count(), 0);

	map.insert( "Torben", MyClass("Weis") );

	QCOMPARE( map.count(), 1 );

	map.insert( "Claudia", MyClass("Sorg") );

	QCOMPARE( map.count(), 2 );

	map.insert( "Lars", MyClass("Linzbach") );

	map.insert( "Matthias", MyClass("Ettrich") );

	map.insert( "Sue", MyClass("Paludo") );

	map.insert( "Eirik", MyClass("Eng") );

	map.insert( "Haavard", MyClass("Nord") );

	map.insert( "Arnt", MyClass("Gulbrandsen") );

	map.insert( "Paul", MyClass("Tvete") );

	QCOMPARE( map.count(), 9 );

	map.insert( "Paul", MyClass("Tvete 1") );

	map.insert( "Paul", MyClass("Tvete 2") );

	map.insert( "Paul", MyClass("Tvete 3") );

	map.insert( "Paul", MyClass("Tvete 4") );

	map.insert( "Paul", MyClass("Tvete 5") );

	map.insert( "Paul", MyClass("Tvete 6") );

	QCOMPARE( map.count(), 9 );

#ifndef Q_CC_SUN

	QCOMPARE( MyClass::count, 9 );

#endif

	Map map2( map );

	QVERIFY( map2.count() == 9 );

#ifndef Q_CC_SUN

	QCOMPARE( MyClass::count, 9 );

#endif

	map2.insert( "Kay", MyClass("Roemer") );

	QVERIFY( map2.count() == 10 );

	QVERIFY( map.count() == 9 );

#ifndef Q_CC_SUN

	QCOMPARE( MyClass::count, 19 );

#endif

	map2 = map;

	QVERIFY( map.count() == 9 );

	QVERIFY( map2.count() == 9 );

#ifndef Q_CC_SUN

	QCOMPARE( MyClass::count, 9 );

#endif

	map2.insert( "Kay", MyClass("Roemer") );

	QVERIFY( map2.count() == 10 );

#ifndef Q_CC_SUN

	QCOMPARE( MyClass::count, 19 );

#endif

	map2.clear();

	QVERIFY( map.count() == 9 );

	QVERIFY( map2.count() == 0 );

#ifndef Q_CC_SUN

	QCOMPARE( MyClass::count, 9 );

#endif

	map2 = map;

	QVERIFY( map.count() == 9 );

	QVERIFY( map2.count() == 9 );

#ifndef Q_CC_SUN

	QCOMPARE( MyClass::count, 9 );

#endif

	map2.clear();

	QVERIFY( map.count() == 9 );

	QVERIFY( map2.count() == 0 );

#ifndef Q_CC_SUN

	QCOMPARE( MyClass::count, 9 );

#endif

	map.remove( "Lars" );

	QVERIFY( map.count() == 8 );

	QVERIFY( map2.count() == 0 );

#ifndef Q_CC_SUN

	QCOMPARE( MyClass::count, 8 );

#endif

	map.remove( "Mist" );

	QVERIFY( map.count() == 8 );

	QVERIFY( map2.count() == 0 );

#ifndef Q_CC_SUN

	QCOMPARE( MyClass::count, 8 );

#endif

    }

    QVERIFY( MyClass::count == 0 );

    {

	typedef QMap<QString,MyClass> Map;

	Map map;

	map["Torben"] = MyClass("Weis");

#ifndef Q_CC_SUN

	QVERIFY( MyClass::count == 1 );

#endif

	QVERIFY( map.count() == 1 );

	(void)map["Torben"].str;

	(void)map["Lars"].str;

#ifndef Q_CC_SUN

	QVERIFY( MyClass::count == 2 );

#endif

	QVERIFY( map.count() == 2 );

	const Map& cmap = map;

	(void)cmap["Depp"].str;

#ifndef Q_CC_SUN

	QVERIFY( MyClass::count == 2 );

#endif

	QVERIFY( map.count() == 2 );

	QVERIFY( cmap.count() == 2 );

    }

    QCOMPARE( MyClass::count, 0 );

    {

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

	{

	    QMap<int, MyClass> map;

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

		map.insert(j, MyClass(QString::number(j)));

	}

	QCOMPARE( MyClass::count, 0 );

    }

    QCOMPARE( MyClass::count, 0 );

}

void tst_QMap::clear()

{

    {

	MyMap map;

	map.clear();

	QVERIFY( map.isEmpty() );

	map.insert( "key", MyClass( "value" ) );

	map.clear();

	QVERIFY( map.isEmpty() );

	map.insert( "key0", MyClass( "value0" ) );

	map.insert( "key0", MyClass( "value1" ) );

	map.insert( "key1", MyClass( "value2" ) );

	map.clear();

	QVERIFY( map.isEmpty() );

    }

    QCOMPARE( MyClass::count, int(0) );

}

void tst_QMap::beginEnd()

{

    StringMap m0;

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

    QVERIFY( m0.begin() == m0.begin() );

    // sample string->string map

    StringMap map;

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

    map.insert( "0", "a" );

    map.insert( "1", "b" );

    // make a copy. const function shouldn't detach

    StringMap map2 = map;

    QVERIFY( map.constBegin() == map2.constBegin() );

    QVERIFY( map.constEnd() == map2.constEnd() );

    // test iteration

    QString result;

    for ( StringMap::ConstIterator it = map.constBegin();

	  it != map.constEnd(); ++it )

	result += *it;

    QCOMPARE( result, QString( "ab" ) );

    // maps should still be identical

    QVERIFY( map.constBegin() == map2.constBegin() );

    QVERIFY( map.constEnd() == map2.constEnd() );

    // detach

    map2.insert( "2", "c" );

    QVERIFY( map.constBegin() == map.constBegin() );

    QVERIFY( map.constBegin() != map2.constBegin() );

}

void tst_QMap::key()

{

    {

        QString def("default value");

        QMap<QString, int> map1;

        QCOMPARE(map1.key(1), QString());

        QCOMPARE(map1.key(1, def), def);

        map1.insert("one", 1);

        QCOMPARE(map1.key(1), QString("one"));

        QCOMPARE(map1.key(1, def), QString("one"));

        QCOMPARE(map1.key(2), QString());

        QCOMPARE(map1.key(2, def), def);

        map1.insert("two", 2);

        QCOMPARE(map1.key(1), QString("one"));

        QCOMPARE(map1.key(1, def), QString("one"));

        QCOMPARE(map1.key(2), QString("two"));

        QCOMPARE(map1.key(2, def), QString("two"));

        QCOMPARE(map1.key(3), QString());

        QCOMPARE(map1.key(3, def), def);

        map1.insert("deux", 2);

        QCOMPARE(map1.key(1), QString("one"));

        QCOMPARE(map1.key(1, def), QString("one"));

        QVERIFY(map1.key(2) == "deux" || map1.key(2) == "two");

        QVERIFY(map1.key(2, def) == "deux" || map1.key(2, def) == "two");

        QCOMPARE(map1.key(3), QString());

        QCOMPARE(map1.key(3, def), def);

    }

    {

        int def = 666;

        QMap<int, QString> map2;

        QCOMPARE(map2.key("one"), 0);

        QCOMPARE(map2.key("one", def), def);

        map2.insert(1, "one");

        QCOMPARE(map2.key("one"), 1);

        QCOMPARE(map2.key("one", def), 1);

        QCOMPARE(map2.key("two"), 0);

        QCOMPARE(map2.key("two", def), def);

        map2.insert(2, "two");

        QCOMPARE(map2.key("one"), 1);

        QCOMPARE(map2.key("one", def), 1);

        QCOMPARE(map2.key("two"), 2);

        QCOMPARE(map2.key("two", def), 2);

        QCOMPARE(map2.key("three"), 0);

        QCOMPARE(map2.key("three", def), def);

        map2.insert(3, "two");

        QCOMPARE(map2.key("one"), 1);

        QCOMPARE(map2.key("one", def), 1);

        QCOMPARE(map2.key("two"), 2);

        QCOMPARE(map2.key("two", def), 2);

        QCOMPARE(map2.key("three"), 0);

        QCOMPARE(map2.key("three", def), def);

        map2.insert(-1, "two");

        QCOMPARE(map2.key("two"), -1);

        QCOMPARE(map2.key("two", def), -1);

        map2.insert(0, "zero");

        QCOMPARE(map2.key("zero"), 0);

        QCOMPARE(map2.key("zero", def), 0);

    }

}

void tst_QMap::operator_eq()

{

    {

        // compare for equality:

        QMap<int, int> a;

        QMap<int, int> b;

        QVERIFY(a == b);

        QVERIFY(!(a != b));

        a.insert(1,1);

        b.insert(1,1);

        QVERIFY(a == b);

        QVERIFY(!(a != b));

        a.insert(0,1);

        b.insert(0,1);

        QVERIFY(a == b);

        QVERIFY(!(a != b));

        // compare for inequality:

        a.insert(42,0);

        QVERIFY(a != b);

        QVERIFY(!(a == b));

        a.insert(65, -1);

        QVERIFY(a != b);

        QVERIFY(!(a == b));

        b.insert(-1, -1);

        QVERIFY(a != b);

        QVERIFY(!(a == b));

    }

    {

        // a more complex map

        QMap<QString, QString> a;

        QMap<QString, QString> b;

        QVERIFY(a == b);

        QVERIFY(!(a != b));

        a.insert("Hello", "World");

        QVERIFY(a != b);

        QVERIFY(!(a == b));

        b.insert("Hello", "World");

        QVERIFY(a == b);

        QVERIFY(!(a != b));

        a.insert("Goodbye", "cruel world");

        QVERIFY(a != b);

        QVERIFY(!(a == b));

        b.insert("Goodbye", "cruel world");

        // what happens if we insert nulls?

        a.insert(QString(), QString());

        QVERIFY(a != b);

        QVERIFY(!(a == b));

        // empty keys and null keys match:

        b.insert(QString(""), QString());

        QVERIFY(a == b);

        QVERIFY(!(a != b));

    }

    {

        // task 102658

        QMap<QString, int> a;

        QMap<QString, int> b;

        a.insert("otto", 1);

        b.insert("willy", 1);

        QVERIFY(a != b);

        QVERIFY(!(a == b));

    }

}

void tst_QMap::empty()

{

    QMap<int, QString> map1;

    QVERIFY(map1.isEmpty());

    map1.insert(1, "one");

    QVERIFY(!map1.isEmpty());

    map1.clear();

    QVERIFY(map1.isEmpty());

}

void tst_QMap::contains()

{

    QMap<int, QString> map1;

    int i;

    map1.insert(1, "one");

    QVERIFY(map1.contains(1));

    for(i=2; i < 100; ++i)

        map1.insert(i, "teststring");

    for(i=99; i > 1; --i)

        QVERIFY(map1.contains(i));

    map1.remove(43);

    QVERIFY(!map1.contains(43));

}

void tst_QMap::find()

{

    QMap<int, QString> map1;

    QString testString="Teststring %0";

    QString compareString;

    int i,count=0;

    QVERIFY(map1.find(1) == map1.end());

    map1.insert(1,"Mensch");

    map1.insert(1,"Mayer");

    map1.insert(2,"Hej");

    QVERIFY(map1.find(1).value() == "Mayer");

    QVERIFY(map1.find(2).value() == "Hej");

    for(i = 3; i < 10; ++i) {

        compareString = testString.arg(i);

        map1.insertMulti(4, compareString);

    }

    QMap<int, QString>::const_iterator it=map1.constFind(4);