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

**

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

QT_USE_NAMESPACE

#if defined(QT_NO_EXCEPTIONS)

    QTEST_NOOP_MAIN

#else

class tst_ExceptionSafety: public QObject

{

    Q_OBJECT

private slots:

    void exceptionInSlot();

    void exceptionVector();

    void exceptionHash();

    void exceptionMap();

    void exceptionList();

    void exceptionLinkedList();

//    void exceptionEventLoop();

//    void exceptionSignalSlot();

};

class Emitter : public QObject

{

    Q_OBJECT

public:

    inline void emitTestSignal() { emit testSignal(); }

signals:

    void testSignal();

};

class ExceptionThrower : public QObject

{

    Q_OBJECT

public slots:

    void thrower() { throw 5; }

};

class Receiver : public QObject

{

    Q_OBJECT

public:

    Receiver()

        : received(0) {}

    int received;

public slots:

    void receiver() { ++received; }

};

enum ThrowType { ThrowNot = 0, ThrowAtCreate = 1, ThrowAtCopy = 2, ThrowLater = 3, ThrowAtComparison = 4 };

ThrowType throwType = ThrowNot; // global flag to indicate when an exception should be throw. Will be reset when the exception has been generated.

int objCounter = 0;

/*! Class that does not throw any exceptions. Used as baseclass for all the other ones.

 */

template <int T>

class FlexibleThrower

{

    public:

        FlexibleThrower() : _value(-1) {

            if( throwType == ThrowAtCreate ) {

                throwType = ThrowNot;

                throw ThrowAtCreate;

            }

            objCounter++;

        }

        FlexibleThrower( short value ) : _value(value) {

            if( throwType == ThrowAtCreate ) {

                throwType = ThrowNot;

                throw ThrowAtCreate;

            }

            objCounter++;

        }

        FlexibleThrower(FlexibleThrower const& other ) {

            // qDebug("cc");

            if( throwType == ThrowAtCopy ) {

                throwType = ThrowNot;

                throw ThrowAtCopy;

            } else if( throwType == ThrowLater ) {

                throwType = ThrowAtCopy;

            }

            objCounter++;

            _value = other.value();

        }

        ~FlexibleThrower() { objCounter--; }

        bool operator==(const FlexibleThrower<T> &t) const

        {

            // qDebug("vv == %d %d", value(), t.value());

            if( throwType == ThrowAtComparison ) {

                throwType = ThrowNot;

                throw ThrowAtComparison;

            }

            return value()==t.value();

        }

        bool operator<(const FlexibleThrower<T> &t) const

        {

            // qDebug("vv < %d %d", value(), t.value());

            if( throwType == ThrowAtComparison ) {

                throwType = ThrowNot;

                throw ThrowAtComparison;

            }

            return value()<t.value();

        }

        int value() const

        { return (int)_value; }

        short _value;

        char dummy[T];

};

uint qHash(const FlexibleThrower<2>& t)

{

    // qDebug("ha");

    if( throwType == ThrowAtComparison ) {

        throwType = ThrowNot;

        throw ThrowAtComparison;

    }

    return (uint)t.value();

}

typedef FlexibleThrower<2> FlexibleThrowerSmall;

typedef QMap<FlexibleThrowerSmall,FlexibleThrowerSmall> MyMap;

typedef QHash<FlexibleThrowerSmall,FlexibleThrowerSmall> MyHash;

// connect a signal to a slot that throws an exception

// run this through valgrind to make sure it doesn't corrupt

void tst_ExceptionSafety::exceptionInSlot()

{

    Emitter emitter;

    ExceptionThrower thrower;

    connect(&emitter, SIGNAL(testSignal()), &thrower, SLOT(thrower()));

    try {

        emitter.emitTestSignal();

    } catch (int i) {

        QCOMPARE(i, 5);

    }

}

void tst_ExceptionSafety::exceptionList() {

    {

        QList<FlexibleThrowerSmall> list;

        QList<FlexibleThrowerSmall> list2;

        QList<FlexibleThrowerSmall> list3;

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

            list.append( FlexibleThrowerSmall(i) );

        try {

            throwType = ThrowAtCopy;

            list.append( FlexibleThrowerSmall(10));

        } catch (...) {

        }

        QCOMPARE( list.size(), 10 );

        try {

            throwType = ThrowAtCopy;

            list.prepend( FlexibleThrowerSmall(10));

        } catch (...) {

        }

        QCOMPARE( list.at(0).value(), 0 );

        QCOMPARE( list.size(), 10 );

        try {

            throwType = ThrowAtCopy;

            list.insert( 8, FlexibleThrowerSmall(10));

        } catch (...) {

        }

        QCOMPARE( list.at(7).value(), 7 );

        QCOMPARE( list.at(8).value(), 8 );

        QCOMPARE( list.size(), 10 );

        try {

            throwType = ThrowAtCopy;

            FlexibleThrowerSmall t = list.takeAt( 6 );

        } catch (...) {

        }

        QCOMPARE( list.at(6).value(), 6 );

        QCOMPARE( list.at(7).value(), 7 );

        QCOMPARE( list.size(), 10 );

        try {

            throwType = ThrowAtCopy;

            list3 = list;

        } catch (...) {

        }

        QCOMPARE( list.at(0).value(), 0 );

        QCOMPARE( list.at(7).value(), 7 );

        QCOMPARE( list.size(), 10 );

        QCOMPARE( list3.at(0).value(), 0 );

        QCOMPARE( list3.at(7).value(), 7 );

        QCOMPARE( list3.size(), 10 );

        try {

            throwType = ThrowAtCopy;

            list3.append( FlexibleThrowerSmall(11) );

        } catch (...) {

        }

        QCOMPARE( list.at(0).value(), 0 );

        QCOMPARE( list.at(7).value(), 7 );

        QCOMPARE( list.size(), 10 );

        QCOMPARE( list3.at(0).value(), 0 );

        QCOMPARE( list3.at(7).value(), 7 );

        QCOMPARE( list3.size(), 10 );

        try {

            list2.clear();

            list2.append( FlexibleThrowerSmall(11));

            throwType = ThrowAtCopy;

            list3 = list+list2;

        } catch (...) {

        }

        QCOMPARE( list.at(0).value(), 0 );

        QCOMPARE( list.at(7).value(), 7 );

        QCOMPARE( list.size(), 10 );

        // check that copy on write works atomar

        list2.clear();

        list2.append( FlexibleThrowerSmall(11));

        list3 = list+list2;

        try {

            throwType = ThrowAtCreate;

            list3[7]=FlexibleThrowerSmall(12);

        } catch (...) {

        }

        QCOMPARE( list.at(7).value(), 7 );

        QCOMPARE( list.size(), 10 );

        QCOMPARE( list3.at(7).value(), 7 );

        QCOMPARE( list3.size(), 11 );

    }

    QCOMPARE(objCounter, 0 ); // check that every object has been freed

}

void tst_ExceptionSafety::exceptionLinkedList() {

    {

        QLinkedList<FlexibleThrowerSmall> list;

        QLinkedList<FlexibleThrowerSmall> list2;

        QLinkedList<FlexibleThrowerSmall> list3;

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

            list.append( FlexibleThrowerSmall(i) );

        try {

            throwType = ThrowAtCopy;

            list.append( FlexibleThrowerSmall(10));

        } catch (...) {

        }

        QCOMPARE( list.size(), 10 );

        try {

            throwType = ThrowAtCopy;

            list.prepend( FlexibleThrowerSmall(10));

        } catch (...) {

        }

        QCOMPARE( list.first().value(), 0 );

        QCOMPARE( list.size(), 10 );

        try {

            throwType = ThrowAtCopy;

            list3 = list;

            list3.append( FlexibleThrowerSmall(11) );

        } catch (...) {

        }

        QCOMPARE( list.first().value(), 0 );

        QCOMPARE( list.size(), 10 );

        QCOMPARE( list3.size(), 10 );

    }

    QCOMPARE(objCounter, 0 ); // check that every object has been freed

}

void tst_ExceptionSafety::exceptionVector() {

    {

        QVector<FlexibleThrowerSmall> vector;

        QVector<FlexibleThrowerSmall> vector2;

        QVector<FlexibleThrowerSmall> vector3;

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

            vector.append( FlexibleThrowerSmall(i) );

        try {

            throwType = ThrowAtCopy;

            vector.append( FlexibleThrowerSmall(10));

        } catch (...) {

        }

        QCOMPARE( vector.size(), 10 );

        try {

            throwType = ThrowAtCopy;

            vector.prepend( FlexibleThrowerSmall(10));

        } catch (...) {

        }

        QCOMPARE( vector.at(0).value(), 0 );

        QCOMPARE( vector.size(), 10 );

        try {

            throwType = ThrowAtCopy;

            vector.insert( 8, FlexibleThrowerSmall(10));

        } catch (...) {

        }

        QCOMPARE( vector.at(7).value(), 7 );

        QCOMPARE( vector.at(8).value(), 8 );

        QCOMPARE( vector.size(), 10 );

        try {

            throwType = ThrowAtCopy;

            vector3 = vector;

        } catch (...) {

        }

        QCOMPARE( vector.at(0).value(), 0 );

        QCOMPARE( vector.at(7).value(), 7 );

        QCOMPARE( vector.size(), 10 );

        QCOMPARE( vector3.at(0).value(), 0 );

        QCOMPARE( vector3.at(7).value(), 7 );

        QCOMPARE( vector3.size(), 10 );

        try {

            throwType = ThrowAtCopy;

            vector3.append( FlexibleThrowerSmall(11) );

        } catch (...) {

        }

        QCOMPARE( vector.at(0).value(), 0 );

        QCOMPARE( vector.at(7).value(), 7 );

        QCOMPARE( vector.size(), 10 );

        QCOMPARE( vector3.at(0).value(), 0 );

        QCOMPARE( vector3.at(7).value(), 7 );

        try {

            vector2.clear();

            vector2.append( FlexibleThrowerSmall(11));

            throwType = ThrowAtCopy;

            vector3 = vector+vector2;

        } catch (...) {

        }

        QCOMPARE( vector.at(0).value(), 0 );

        QCOMPARE( vector.at(7).value(), 7 );

        QCOMPARE( vector.size(), 10 );

        // check that copy on write works atomar

        vector2.clear();

        vector2.append( FlexibleThrowerSmall(11));

        vector3 = vector+vector2;

        try {

            throwType = ThrowAtCreate;

            vector3[7]=FlexibleThrowerSmall(12);

        } catch (...) {

        }

        QCOMPARE( vector.at(7).value(), 7 );

        QCOMPARE( vector.size(), 10 );

        QCOMPARE( vector3.at(7).value(), 7 );

        QCOMPARE( vector3.size(), 11 );

        try {

            throwType = ThrowAtCreate;

            vector.resize(15);

        } catch (...) {

        }

        QCOMPARE( vector.at(7).value(), 7 );

        QCOMPARE( vector.size(), 10 );

        try {

            throwType = ThrowAtCreate;

            vector.resize(15);

        } catch (...) {

        }

        QCOMPARE( vector.at(7).value(), 7 );

        QCOMPARE( vector.size(), 10 );

        try {

            throwType = ThrowLater;

            vector.fill(FlexibleThrowerSmall(1), 15);

        } catch (...) {

        }

        QCOMPARE( vector.at(0).value(), 0 );

        QCOMPARE( vector.size(), 10 );

    }

    QCOMPARE(objCounter, 0 ); // check that every object has been freed

}

void tst_ExceptionSafety::exceptionMap() {

    {

        MyMap map;

        MyMap map2;

        MyMap map3;

        throwType = ThrowNot;

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

            map[ FlexibleThrowerSmall(i) ] = FlexibleThrowerSmall(i);

        return; // further test are deactivated until Map is fixed.

        for( int i = ThrowAtCopy; i<=ThrowAtComparison; i++ ) {

            try {

                throwType = (ThrowType)i;

                map[ FlexibleThrowerSmall(10) ] = FlexibleThrowerSmall(10);

            } catch(...) {

            }

            QCOMPARE( map.size(), 10 );

            QCOMPARE( map[ FlexibleThrowerSmall(1) ], FlexibleThrowerSmall(1) );

        }

        map2 = map;

        try {

            throwType = ThrowLater;

            map2[ FlexibleThrowerSmall(10) ] = FlexibleThrowerSmall(10);

        } catch(...) {

        }

        /* qDebug("%d %d", map.size(), map2.size() );

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

            qDebug( "Value at %d: %d",i, map.value(FlexibleThrowerSmall(i), FlexibleThrowerSmall()).value() );

        QCOMPARE( map.value(FlexibleThrowerSmall(1), FlexibleThrowerSmall()), FlexibleThrowerSmall(1) );

        qDebug( "Value at %d: %d",1, map[FlexibleThrowerSmall(1)].value() );

        qDebug("%d %d", map.size(), map2.size() );

        */

        QCOMPARE( map[ FlexibleThrowerSmall(1) ], FlexibleThrowerSmall(1) );

        QCOMPARE( map.size(), 10 );

        QCOMPARE( map2[ FlexibleThrowerSmall(1) ], FlexibleThrowerSmall(1) );

        QCOMPARE( map2.size(), 10 );

    }

    QCOMPARE(objCounter, 0 ); // check that every object has been freed

}

void tst_ExceptionSafety::exceptionHash() {

    {

        MyHash hash;

        MyHash hash2;

        MyHash hash3;

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

            hash[ FlexibleThrowerSmall(i) ] = FlexibleThrowerSmall(i);

        for( int i = ThrowAtCopy; i<=ThrowAtComparison; i++ ) {

            try {

                throwType = (ThrowType)i;

                hash[ FlexibleThrowerSmall(10) ] = FlexibleThrowerSmall(10);

            } catch(...) {

            }

            QCOMPARE( hash.size(), 10 );

        }

        hash2 = hash;

        try {

            throwType = ThrowLater;

            hash2[ FlexibleThrowerSmall(10) ] = FlexibleThrowerSmall(10);

        } catch(...) {

        }

        QCOMPARE( hash[ FlexibleThrowerSmall(1) ], FlexibleThrowerSmall(1) );

        QCOMPARE( hash.size(), 10 );

        QCOMPARE( hash2[ FlexibleThrowerSmall(1) ], FlexibleThrowerSmall(1) );

        QCOMPARE( hash2.size(), 10 );

        hash2.clear();

        try {

            throwType = ThrowLater;

            hash2.reserve(30);

        } catch(...) {

        }

        QCOMPARE( hash2.size(), 0 );

        /*

           try {

           throwType = ThrowAtCopy;

           hash.prepend( FlexibleThrowerSmall(10));

           } catch (...) {

           }