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

**

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

**

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

#define QT3_SUPPORT

#include <QtTest/QtTest>

#include <qcoreapplication.h>

#include <qpointer.h>

#include <qtimer.h>

#include <qregexp.h>

#include <qmetaobject.h>

#include <qvariant.h>

#include <QTcpServer>

#include <QTcpSocket>

#include <QThread>

#include <QMutex>

#include <QWaitCondition>

#include <QProcess>

#include "qobject.h"

#include <math.h>

//TESTED_CLASS=

//TESTED_FILES=

class tst_QObject : public QObject

{

    Q_OBJECT

public:

    tst_QObject();

    virtual ~tst_QObject();

public slots:

    void initTestCase();

    void cleanupTestCase();

    void init();

    void cleanup();

private slots:

    void disconnect();

    void connectByName();

    void connectSignalsToSignalsWithDefaultArguments();

    void receivers();

    void normalize();

    void qobject_castTemplate();

    void findChildren();

    void connectDisconnectNotify_data();

    void connectDisconnectNotify();

    void emitInDefinedOrder();

    void customTypes();

    void streamCustomTypes();

    void metamethod();

    void namespaces();

    void threadSignalEmissionCrash();

    void thread();

    void thread0();

    void moveToThread();

    void sender();

    void declareInterface();

    void qpointerResetBeforeDestroyedSignal();

    void testUserData();

    void childDeletesItsSibling();

    void dynamicProperties();

    void floatProperty();

    void qrealProperty();

    void property();

    void recursiveSignalEmission();

    void blockingQueuedConnection();

    void compatibilityChildInsertedEvents();

    void installEventFilter();

    void deleteSelfInSlot();

    void disconnectSelfInSlotAndDeleteAfterEmit();

    void dumpObjectInfo();

    void connectToSender();

    void qobjectConstCast();

    void uniqConnection();

    void interfaceIid();

    void deleteQObjectWhenDeletingEvent();

    void overloads();

protected:

};

tst_QObject::tst_QObject()

{

}

tst_QObject::~tst_QObject()

{

}

void tst_QObject::initTestCase()

{

}

void tst_QObject::cleanupTestCase()

{

}

void tst_QObject::init()

{

}

void tst_QObject::cleanup()

{

}

class SenderObject : public QObject

{

    Q_OBJECT

public:

    SenderObject() : recursionCount(0) {}

    void emitSignal1AfterRecursion()

    {

        if (recursionCount++ < 100)

            emitSignal1AfterRecursion();

        else

            emitSignal1();

    }

    void emitSignal1() { emit signal1(); }

    void emitSignal2() { emit signal2(); }

    void emitSignal3() { emit signal3(); }

    void emitSignal4() { emit signal4(); }

signals:

    void signal1();

    void signal2();

    void signal3();

    void signal4();

    QT_MOC_COMPAT void signal5();

public slots:

    void aPublicSlot(){}

public:

    Q_INVOKABLE void invoke1(){}

    Q_SCRIPTABLE void sinvoke1(){}

protected:

    Q_INVOKABLE QT_MOC_COMPAT void invoke2(){}

    Q_INVOKABLE QT_MOC_COMPAT void invoke2(int){}

    Q_SCRIPTABLE QT_MOC_COMPAT void sinvoke2(){}

private:

    Q_INVOKABLE void invoke3(int hinz = 0, int kunz = 0){Q_UNUSED(hinz) Q_UNUSED(kunz)}

    Q_SCRIPTABLE void sinvoke3(){}

    int recursionCount;

};

class ReceiverObject : public QObject

{

    Q_OBJECT

public:

    ReceiverObject() : sequence_slot1( 0 ),

		       sequence_slot2( 0 ),

		       sequence_slot3( 0 ),

		       sequence_slot4( 0 ) {}

    void reset() {

	sequence_slot4 = 0;

	sequence_slot3 = 0;

	sequence_slot2 = 0;

	sequence_slot1 = 0;

        count_slot1 = 0;

        count_slot2 = 0;

        count_slot3 = 0;

        count_slot4 = 0;

    }

    int sequence_slot1;

    int sequence_slot2;

    int sequence_slot3;

    int sequence_slot4;

    int count_slot1;

    int count_slot2;

    int count_slot3;

    int count_slot4;

    bool called(int slot) {

        switch (slot) {

        case 1: return sequence_slot1;

        case 2: return sequence_slot2;

        case 3: return sequence_slot3;

        case 4: return sequence_slot4;

        default: return false;

        }

    }

    static int sequence;

public slots:

    void slot1() { sequence_slot1 = ++sequence; count_slot1++; }

    void slot2() { sequence_slot2 = ++sequence; count_slot2++; }

    void slot3() { sequence_slot3 = ++sequence; count_slot3++; }

    void slot4() { sequence_slot4 = ++sequence; count_slot4++; }

};

int ReceiverObject::sequence = 0;

void tst_QObject::disconnect()

{

    SenderObject *s = new SenderObject;

    ReceiverObject *r1 = new ReceiverObject;

    ReceiverObject *r2 = new ReceiverObject;

    connect( s, SIGNAL( signal1() ), r1, SLOT( slot1() ) );

    connect( s, SIGNAL( signal2() ), r1, SLOT( slot2() ) );

    connect( s, SIGNAL( signal3() ), r1, SLOT( slot3() ) );

    connect( s, SIGNAL( signal4() ), r1, SLOT( slot4() ) );

    s->emitSignal1();

    s->emitSignal2();

    s->emitSignal3();

    s->emitSignal4();

    QCOMPARE( r1->called(1), TRUE );

    QCOMPARE( r1->called(2), TRUE );

    QCOMPARE( r1->called(3), TRUE );

    QCOMPARE( r1->called(4), TRUE );

    r1->reset();

    // usual disconnect with all parameters given

    bool ret = QObject::disconnect( s, SIGNAL( signal1() ), r1, SLOT( slot1() ) );

    s->emitSignal1();

    QCOMPARE( r1->called(1), FALSE );

    r1->reset();

    QCOMPARE( ret, TRUE );

    ret = QObject::disconnect( s, SIGNAL( signal1() ), r1, SLOT( slot1() ) );

    QCOMPARE( ret, FALSE  );

    // disconnect all signals from s from all slots from r1

    QObject::disconnect( s, 0, r1, 0 );

    s->emitSignal2();

    s->emitSignal3();

    s->emitSignal4();

    QCOMPARE( r1->called(2), FALSE );

    QCOMPARE( r1->called(3), FALSE );

    QCOMPARE( r1->called(4), FALSE );

    r1->reset();

    connect( s, SIGNAL( signal1() ), r1, SLOT( slot1() ) );

    connect( s, SIGNAL( signal1() ), r1, SLOT( slot2() ) );

    connect( s, SIGNAL( signal1() ), r1, SLOT( slot3() ) );

    connect( s, SIGNAL( signal2() ), r1, SLOT( slot4() ) );

    // disconnect s's signal1() from all slots of r1

    QObject::disconnect( s, SIGNAL( signal1() ), r1, 0 );

    s->emitSignal1();

    s->emitSignal2();

    QCOMPARE( r1->called(1), FALSE );

    QCOMPARE( r1->called(2), FALSE );

    QCOMPARE( r1->called(3), FALSE );

    QCOMPARE( r1->called(4), TRUE );

    r1->reset();

    // make sure all is disconnected again

    QObject::disconnect( s, 0, r1, 0 );

    connect( s, SIGNAL( signal1() ), r1, SLOT( slot1() ) );

    connect( s, SIGNAL( signal1() ), r2, SLOT( slot1() ) );

    connect( s, SIGNAL( signal2() ), r1, SLOT( slot2() ) );

    connect( s, SIGNAL( signal2() ), r2, SLOT( slot2() ) );

    connect( s, SIGNAL( signal3() ), r1, SLOT( slot3() ) );

    connect( s, SIGNAL( signal3() ), r2, SLOT( slot3() ) );

    // disconnect signal1() from all receivers

    QObject::disconnect( s, SIGNAL( signal1() ), 0, 0 );

    s->emitSignal1();

    s->emitSignal2();

    s->emitSignal3();

    QCOMPARE( r1->called(1), FALSE );

    QCOMPARE( r2->called(1), FALSE );

    QCOMPARE( r1->called(2), TRUE );

    QCOMPARE( r2->called(2), TRUE );

    QCOMPARE( r1->called(2), TRUE );

    QCOMPARE( r2->called(2), TRUE );

    r1->reset();

    r2->reset();

    // disconnect all signals of s from all receivers

    QObject::disconnect( s, 0, 0, 0 );

    QCOMPARE( r1->called(2), FALSE );

    QCOMPARE( r2->called(2), FALSE );

    QCOMPARE( r1->called(2), FALSE );

    QCOMPARE( r2->called(2), FALSE );

    delete r2;

    delete r1;

    delete s;

}

class AutoConnectSender : public QObject

{

    Q_OBJECT

public:

    AutoConnectSender(QObject *parent)

        : QObject(parent)

    {}

    void emitSignalNoParams() { emit signalNoParams(); }

    void emitSignalWithParams(int i) { emit signalWithParams(i); }

    void emitSignalWithParams(int i, QString string) { emit signalWithParams(i, string); }

    void emitSignalManyParams(int i1, int i2, int i3, QString string, bool onoff) { emit signalManyParams(i1, i2, i3, string, onoff); }

    void emitSignalManyParams2(int i1, int i2, int i3, QString string, bool onoff) { emit signalManyParams2(i1, i2, i3, string, onoff); }

    void emitSignalLoopBack() { emit signalLoopBack(); }

signals:

    void signalNoParams();

    void signalWithParams(int i);

    void signalWithParams(int i, QString string);

    void signalManyParams(int i1, int i2, int i3, QString string, bool onoff);

    void signalManyParams(int i1, int i2, int i3, QString string, bool onoff, bool);

    void signalManyParams2(int i1, int i2, int i3, QString string, bool onoff);

    void signalLoopBack();

};

class AutoConnectReceiver : public QObject

{

    Q_OBJECT

public:

    AutoConnectReceiver()

    {

        reset();

        connect(this, SIGNAL(on_Sender_signalLoopBack()), this, SLOT(slotLoopBack()));

    }

    void reset() {

        called_slot8 = 0;

        called_slot7 = 0;

        called_slot6 = 0;

        called_slot5 = 0;

        called_slot4 = 0;

        called_slot3 = 0;

        called_slot2 = 0;

        called_slot1 = 0;

    }

    int called_slot1;

    int called_slot2;

    int called_slot3;

    int called_slot4;

    int called_slot5;

    int called_slot6;

    int called_slot7;

    int called_slot8;

    bool called(int slot) {

        switch (slot) {

        case 1: return called_slot1;

        case 2: return called_slot2;

        case 3: return called_slot3;

        case 4: return called_slot4;

        case 5: return called_slot5;

        case 6: return called_slot6;

        case 7: return called_slot7;

        case 8: return called_slot8;

        default: return false;

        }

    }

public slots:

    void on_Sender_signalNoParams() { ++called_slot1; }

    void on_Sender_signalWithParams(int i = 0) { ++called_slot2; }

    void on_Sender_signalWithParams(int i, QString string) { ++called_slot3; }

    void on_Sender_signalManyParams() { ++called_slot4; }

    void on_Sender_signalManyParams(int i1, int i2, int i3, QString string, bool onoff) { ++called_slot5; }

    void on_Sender_signalManyParams(int i1, int i2, int i3, QString string, bool onoff, bool dummy) { ++called_slot6; }

    void on_Sender_signalManyParams2(int i1, int i2, int i3, QString string, bool onoff) { ++called_slot7; }

    void slotLoopBack() { ++called_slot8; }

protected slots:

    void o() { Q_ASSERT(0); }

    void on() { Q_ASSERT(0); }

signals:

    void on_Sender_signalLoopBack();

};

void tst_QObject::connectByName()

{

    AutoConnectReceiver receiver;

    AutoConnectSender sender(&receiver);

    sender.setObjectName("Sender");

    QMetaObject::connectSlotsByName(&receiver);

    sender.emitSignalNoParams();

    QCOMPARE(receiver.called(1), true);

    QCOMPARE(receiver.called(2), false);

    QCOMPARE(receiver.called(3), false);

    QCOMPARE(receiver.called(4), false);

    QCOMPARE(receiver.called(5), false);

    QCOMPARE(receiver.called(6), false);

    QCOMPARE(receiver.called(7), false);

    QCOMPARE(receiver.called(8), false);

    receiver.reset();

    sender.emitSignalWithParams(0);

    QCOMPARE(receiver.called(1), false);

    QCOMPARE(receiver.called(2), true);

    QCOMPARE(receiver.called(3), false);

    QCOMPARE(receiver.called(4), false);

    QCOMPARE(receiver.called(5), false);

    QCOMPARE(receiver.called(6), false);

    QCOMPARE(receiver.called(7), false);

    QCOMPARE(receiver.called(8), false);

    receiver.reset();

    sender.emitSignalWithParams(0, "string");

    QCOMPARE(receiver.called(1), false);

    QCOMPARE(receiver.called(2), false);

    QCOMPARE(receiver.called(3), true);

    QCOMPARE(receiver.called(4), false);

    QCOMPARE(receiver.called(5), false);

    QCOMPARE(receiver.called(6), false);

    QCOMPARE(receiver.called(7), false);

    QCOMPARE(receiver.called(8), false);

    receiver.reset();

    sender.emitSignalManyParams(1, 2, 3, "string", true);

    QCOMPARE(receiver.called(1), false);

    QCOMPARE(receiver.called(2), false);

    QCOMPARE(receiver.called(3), false);

    QCOMPARE(receiver.called(4), true);

    QCOMPARE(receiver.called(5), true);

    QCOMPARE(receiver.called(6), false);

    QCOMPARE(receiver.called(7), false);

    QCOMPARE(receiver.called(8), false);

    receiver.reset();

    sender.emitSignalManyParams2(1, 2, 3, "string", true);

    QCOMPARE(receiver.called(1), false);

    QCOMPARE(receiver.called(2), false);

    QCOMPARE(receiver.called(3), false);

    QCOMPARE(receiver.called(4), false);

    QCOMPARE(receiver.called(5), false);

    QCOMPARE(receiver.called(6), false);

    QCOMPARE(receiver.called(7), true);

    QCOMPARE(receiver.called(8), false);

    receiver.reset();

    sender.emitSignalLoopBack();

    QCOMPARE(receiver.called(1), false);

    QCOMPARE(receiver.called(2), false);

    QCOMPARE(receiver.called(3), false);

    QCOMPARE(receiver.called(4), false);

    QCOMPARE(receiver.called(5), false);

    QCOMPARE(receiver.called(6), false);

    QCOMPARE(receiver.called(7), false);

    QCOMPARE(receiver.called(8), true);

    receiver.reset();

}

void tst_QObject::qobject_castTemplate()

{

    QObject *o = 0;

    QVERIFY( !::qobject_cast<QObject*>(o) );

    o = new SenderObject;

    QVERIFY( ::qobject_cast<SenderObject*>(o) );

    QVERIFY( ::qobject_cast<QObject*>(o) );

    QVERIFY( !::qobject_cast<ReceiverObject*>(o) );

    delete o;

}

void tst_QObject::findChildren()